Fixed #1990

localDev/src/index.js

@@ -65,51 +65,67 @@ var createScene = function () {
     var target3 = BABYLON.MorphTarget.FromMesh(sphere5, "sphere5", 0.25);
     manager.addTarget(target3);       
 
-    var gui = new dat.GUI();
-    var options = {
-	    influence0: 0.25,
-        influence1: 0.25,
-        influence2: 0.25,
-        influence3: 0.25,
-    }
+    var data = BABYLON.SceneSerializer.Serialize(scene);
 
-    gui.add(options, "influence0", 0, 1).onChange(function(value) {
-		target0.influence = value;
-    });
+    scene.dispose();
 
-    gui.add(options, "influence1", 0, 1).onChange(function(value) {
-		target1.influence = value;
-    });
+    var strScene = JSON.stringify(data);
+	var scene = new BABYLON.Scene(engine);
+    BABYLON.SceneLoader.Append("", "data:" + strScene, scene, function (newScene) {
+
+        var gui = new dat.GUI();
+        var options = {
+            influence0: 0.25,
+            influence1: 0.25,
+            influence2: 0.25,
+            influence3: 0.25,
+        }
+
+        var manager = scene.morphTargetManagers[0];
 
-    gui.add(options, "influence2", 0, 1).onChange(function(value) {
-		target2.influence = value;
-    });  
+        target0 = manager.getActiveTarget(0);
+        target1 = manager.getActiveTarget(1);
+        target2 = manager.getActiveTarget(2);
+        target3 = manager.getActiveTarget(3);
 
-    gui.add(options, "influence3", 0, 1).onChange(function(value) {
-		target3.influence = value;
-    });        
+        gui.add(options, "influence0", 0, 1).onChange(function(value) {
+            target0.influence = value;
+        });
 
-    var button = { switch:function(){
-         if (sphere.morphTargetManager) {
-             sphere.morphTargetManager = null;
-         } else {
-             sphere.morphTargetManager = manager;
-         }
-    }};
+        gui.add(options, "influence1", 0, 1).onChange(function(value) {
+            target1.influence = value;
+        });
 
-    gui.add(button,'switch');
+        gui.add(options, "influence2", 0, 1).onChange(function(value) {
+            target2.influence = value;
+        });  
 
-    var disposeButton = { dispose:function(){
-         sphere.dispose();
-    }};
+        gui.add(options, "influence3", 0, 1).onChange(function(value) {
+            target3.influence = value;
+        });        
 
-    gui.add(disposeButton,'dispose');
+        var button = { switch:function(){
+            if (sphere.morphTargetManager) {
+                sphere.morphTargetManager = null;
+            } else {
+                sphere.morphTargetManager = manager;
+            }
+        }};
 
-    var removeButton = { removeLast:function(){
-         manager.removeTarget(target3);   
-    }};
+        gui.add(button,'switch');
 
-    gui.add(removeButton,'removeLast');
+        var disposeButton = { dispose:function(){
+            sphere.dispose();
+        }};
+
+        gui.add(disposeButton,'dispose');
+
+        var removeButton = { removeLast:function(){
+            manager.removeTarget(target3);   
+        }};
+
+        gui.add(removeButton,'removeLast');
+    });
 
 
     return scene;

src/Loading/Plugins/babylon.babylonFileLoader.ts

@@ -309,6 +309,13 @@
                         log += "\n\t\t" + mmat.toString(fullDetails);
                     }
                 }
+
+                // Morph targets
+                if (parsedData.morphTargetManagers) {
+                    for (var managerData of parsedData.morphTargetManagers) {
+                        var parsedManager = MorphTargetManager.Parse(managerData, scene);
+                    }
+                }
     
                 // Skeletons
                 if (parsedData.skeletons) {

src/Mesh/babylon.mesh.ts

@@ -1928,6 +1928,11 @@
                 this.material = null;
             }
 
+            // Morph targets
+            if (this.morphTargetManager) {
+                serializationObject.morphTargetManagerId = this.morphTargetManager.uniqueId;
+            }
+
             // Skeleton
             if (this.skeleton) {
                 serializationObject.skeletonId = this.skeleton.id;
@@ -1969,6 +1974,8 @@
                 serializationInstance.ranges = instance.serializeAnimationRanges();
             }
 
+            // 
+
             // Animations
             Animation.AppendSerializedAnimations(this, serializationObject);
             serializationObject.ranges = this.serializeAnimationRanges();
@@ -2200,6 +2207,11 @@
                 mesh.material = null;
             }
 
+            // Morph targets
+            if (parsedMesh.morphTargetManagerId > -1) {
+                mesh.morphTargetManager = scene.getMorphTargetManagerById(parsedMesh.morphTargetManagerId);
+            }
+
             // Skeleton
             if (parsedMesh.skeletonId > -1) {
                 mesh.skeleton = scene.getLastSkeletonByID(parsedMesh.skeletonId);

src/Morph/babylon.morphTarget.ts

@@ -57,15 +57,27 @@ module BABYLON {
             serializationObject.name = this.name;
             serializationObject.influence = this.influence;
 
-            serializationObject.positions = this.getPositions();
+            serializationObject.positions = Array.prototype.slice.call(this.getPositions());
             if (this.hasNormals) {
-                serializationObject.normals = this.getNormals();
+                serializationObject.normals = Array.prototype.slice.call(this.getNormals());
             }
 
             return serializationObject;
         }
 
         // Statics
+        public static Parse(serializationObject: any): MorphTarget {
+            var result = new MorphTarget(serializationObject.name , serializationObject.influence);
+
+            result.setPositions(serializationObject.positions);
+
+            if (serializationObject.normals) {
+                result.setNormals(serializationObject.normals);
+            }
+
+            return result;
+        }
+
         public static FromMesh(mesh: AbstractMesh, name?: string, influence?: number): MorphTarget {
             if (!name) {
                 name = mesh.name;

src/Morph/babylon.morphTargetManager.ts

@@ -16,6 +16,8 @@ module BABYLON {
 
             this._scene = scene;
 
+            this._scene.morphTargetManagers.push(this);
+
             this._uniqueId = scene.getUniqueId();
         }
 
@@ -118,5 +120,18 @@ module BABYLON {
                 }
             }
         }
+
+        // Statics
+        public static Parse(serializationObject: any, scene: Scene): MorphTargetManager {
+            var result = new MorphTargetManager(scene);
+
+            result._uniqueId = serializationObject.id;
+
+            for (var targetData of serializationObject.targets) {
+                result.addTarget(MorphTarget.Parse(targetData));
+            }
+
+            return result;
+        }
     }
 }

src/Tools/babylon.sceneSerializer.ts

@@ -148,6 +148,16 @@
                 serializationObject.metadata = scene.metadata;
             }
 
+            // Morph targets
+            serializationObject.morphTargetManagers = [];
+            for (var abstractMesh of scene.meshes) {
+                var manager = (<Mesh>abstractMesh).morphTargetManager;
+                
+                if (manager) {
+                    serializationObject.morphTargetManagers.push(manager.serialize());
+                }
+            }            
+
             // Lights
             serializationObject.lights = [];
             var index: number;

src/babylon.scene.ts

@@ -566,6 +566,9 @@
 
         public skeletons = new Array<Skeleton>();
 
+        // Morph targets
+        public morphTargetManagers = new Array<MorphTargetManager>();
+
         // Lens flares
         public lensFlaresEnabled = true;
         public lensFlareSystems = new Array<LensFlareSystem>();
@@ -1703,13 +1706,23 @@
         public removeSkeleton(toRemove: Skeleton): number {
             var index = this.skeletons.indexOf(toRemove);
             if (index !== -1) {
-                // Remove from the scene if mesh found 
+                // Remove from the scene if found 
                 this.skeletons.splice(index, 1);
             }
 
             return index;
         }
 
+        public removeMorphTargetManager(toRemove: MorphTargetManager): number {
+            var index = this.morphTargetManagers.indexOf(toRemove);
+            if (index !== -1) {
+                // Remove from the scene if found 
+                this.morphTargetManagers.splice(index, 1);
+            }
+
+            return index;
+        }
+
         public removeLight(toRemove: Light): number {
             var index = this.lights.indexOf(toRemove);
             if (index !== -1) {
@@ -2234,6 +2247,16 @@
             return null;
         }
 
+        public getMorphTargetManagerById(id: number): MorphTargetManager {
+            for (var index = 0; index < this.morphTargetManagers.length; index++) {
+                if (this.morphTargetManagers[index].uniqueId === id) {
+                    return this.morphTargetManagers[index];
+                }
+            }
+
+            return null;
+        }
+
         public isActiveMesh(mesh: Mesh): boolean {
             return (this._activeMeshes.indexOf(mesh) !== -1);
         }
@@ -3033,6 +3056,7 @@
             this.afterRender = null;
 
             this.skeletons = [];
+            this.morphTargetManagers = [];
 
             this._boundingBoxRenderer.dispose();