Keep working on serialization refactoring

src/Bones/babylon.skeleton.js

@@ -103,8 +103,27 @@ var BABYLON;
             // Remove from scene
             this.getScene().removeSkeleton(this);
         };
+        Skeleton.prototype.serialize = function () {
+            var serializationObject = {};
+            serializationObject.name = this.name;
+            serializationObject.id = this.id;
+            serializationObject.bones = [];
+            for (var index = 0; index < this.bones.length; index++) {
+                var bone = this.bones[index];
+                var serializedBone = {
+                    parentBoneIndex: bone.getParent() ? this.bones.indexOf(bone.getParent()) : -1,
+                    name: bone.name,
+                    matrix: bone.getLocalMatrix().toArray()
+                };
+                serializationObject.bones.push(serializedBone);
+                if (bone.animations && bone.animations.length > 0) {
+                    serializedBone.animation = bone.animations[0].serialize();
+                }
+            }
+            return serializationObject;
+        };
         Skeleton.ParseSkeleton = function (parsedSkeleton, scene) {
-            var skeleton = new BABYLON.Skeleton(parsedSkeleton.name, parsedSkeleton.id, scene);
+            var skeleton = new Skeleton(parsedSkeleton.name, parsedSkeleton.id, scene);
             for (var index = 0; index < parsedSkeleton.bones.length; index++) {
                 var parsedBone = parsedSkeleton.bones[index];
                 var parentBone = null;

src/Bones/babylon.skeleton.ts

@@ -136,9 +136,35 @@
             // Remove from scene
             this.getScene().removeSkeleton(this);
         }
+
+        public serialize(): any {
+            var serializationObject: any = {};
+
+            serializationObject.name = this.name;
+            serializationObject.id = this.id;
+
+            serializationObject.bones = [];
+
+            for (var index = 0; index < this.bones.length; index++) {
+                var bone = this.bones[index];
+
+                var serializedBone: any = {
+                    parentBoneIndex: bone.getParent() ? this.bones.indexOf(bone.getParent()) : -1,
+                    name: bone.name,
+                    matrix: bone.getLocalMatrix().toArray()
+                };
+
+                serializationObject.bones.push(serializedBone);
+
+                if (bone.animations && bone.animations.length > 0) {
+                    serializedBone.animation = bone.animations[0].serialize();
+                }
+            }
+            return serializationObject;
+        }
         
-        public static ParseSkeleton(parsedSkeleton: any, scene: BABYLON.Scene) : BABYLON.Skeleton {
-            var skeleton = new BABYLON.Skeleton(parsedSkeleton.name, parsedSkeleton.id, scene);
+        public static ParseSkeleton(parsedSkeleton: any, scene: Scene) : Skeleton {
+            var skeleton = new Skeleton(parsedSkeleton.name, parsedSkeleton.id, scene);
 
             for (var index = 0; index < parsedSkeleton.bones.length; index++) {
                 var parsedBone = parsedSkeleton.bones[index];
@@ -148,7 +174,7 @@
                     parentBone = skeleton.bones[parsedBone.parentBoneIndex];
                 }
     
-                var bone = new BABYLON.Bone(parsedBone.name, skeleton, parentBone, BABYLON.Matrix.FromArray(parsedBone.matrix));
+                var bone = new Bone(parsedBone.name, skeleton, parentBone, Matrix.FromArray(parsedBone.matrix));
     
                 if (parsedBone.animation) {
                     bone.animations.push(Animation.ParseAnimation(parsedBone.animation));

src/Cameras/babylon.arcRotateCamera.js

@@ -553,6 +553,20 @@ var BABYLON;
             }
             _super.prototype._updateRigCameras.call(this);
         };
+        ArcRotateCamera.prototype.serialize = function () {
+            var serializationObject = _super.prototype.serialize.call(this);
+            if (this.target instanceof BABYLON.Vector3) {
+                serializationObject.target = this.target.asArray();
+            }
+            if (this.target && this.target.id) {
+                serializationObject.lockedTargetId = this.target.id;
+            }
+            serializationObject.checkCollisions = this.checkCollisions;
+            serializationObject.alpha = this.alpha;
+            serializationObject.beta = this.beta;
+            serializationObject.radius = this.radius;
+            return serializationObject;
+        };
         return ArcRotateCamera;
     })(BABYLON.TargetCamera);
     BABYLON.ArcRotateCamera = ArcRotateCamera;

src/Cameras/babylon.arcRotateCamera.ts

@@ -648,7 +648,25 @@
             }
             super._updateRigCameras();
         }
-    }
-} 
 
+        public serialize(): any {
+            var serializationObject = super.serialize();
+
+            if (this.target instanceof Vector3) {
+                serializationObject.target = this.target.asArray();
+            }
+
+            if (this.target && this.target.id) {
+                serializationObject.lockedTargetId = this.target.id;
+            }
 
+            serializationObject.checkCollisions = this.checkCollisions;
+
+            serializationObject.alpha = this.alpha;
+            serializationObject.beta = this.beta;
+            serializationObject.radius = this.radius;
+
+            return serializationObject;
+        }
+    }
+} 

src/Cameras/babylon.camera.js

@@ -516,16 +516,38 @@ var BABYLON;
                 this._rigCameras[0].viewport = this._rigCameras[1].viewport = this.viewport;
             }
         };
+        Camera.prototype.serialize = function () {
+            var serializationObject = {};
+            serializationObject.name = this.name;
+            serializationObject.tags = BABYLON.Tags.GetTags(this);
+            serializationObject.id = this.id;
+            serializationObject.position = this.position.asArray();
+            serializationObject.type = BABYLON.Tools.GetConstructorName(this);
+            // Parent
+            if (this.parent) {
+                serializationObject.parentId = this.parent.id;
+            }
+            serializationObject.fov = this.fov;
+            serializationObject.minZ = this.minZ;
+            serializationObject.maxZ = this.maxZ;
+            serializationObject.inertia = this.inertia;
+            // Animations
+            BABYLON.Animation.AppendSerializedAnimations(this, serializationObject);
+            // Layer mask
+            serializationObject.layerMask = this.layerMask;
+            return serializationObject;
+        };
         Camera.ParseCamera = function (parsedCamera, scene) {
             var camera;
             var position = BABYLON.Vector3.FromArray(parsedCamera.position);
             var lockedTargetMesh = (parsedCamera.lockedTargetId) ? scene.getLastMeshByID(parsedCamera.lockedTargetId) : null;
+            var interaxial_distance;
             if (parsedCamera.type === "AnaglyphArcRotateCamera" || parsedCamera.type === "ArcRotateCamera") {
                 var alpha = parsedCamera.alpha;
                 var beta = parsedCamera.beta;
                 var radius = parsedCamera.radius;
                 if (parsedCamera.type === "AnaglyphArcRotateCamera") {
-                    var interaxial_distance = parsedCamera.interaxial_distance;
+                    interaxial_distance = parsedCamera.interaxial_distance;
                     camera = new BABYLON.AnaglyphArcRotateCamera(parsedCamera.name, alpha, beta, radius, lockedTargetMesh, interaxial_distance, scene);
                 }
                 else {

src/Cameras/babylon.camera.ts

@@ -585,17 +585,47 @@
             }
         }
 
+        public serialize(): any {
+            var serializationObject: any = {};
+            serializationObject.name = this.name;
+            serializationObject.tags = Tags.GetTags(this);
+            serializationObject.id = this.id;
+            serializationObject.position = this.position.asArray();
+
+            serializationObject.type = Tools.GetConstructorName(this);
+
+            // Parent
+            if (this.parent) {
+                serializationObject.parentId = this.parent.id;
+            }
+
+            serializationObject.fov = this.fov;
+            serializationObject.minZ = this.minZ;
+            serializationObject.maxZ = this.maxZ;
+
+            serializationObject.inertia = this.inertia;
+            
+            // Animations
+            Animation.AppendSerializedAnimations(this, serializationObject);
+
+            // Layer mask
+            serializationObject.layerMask = this.layerMask;
+
+            return serializationObject;
+        }
+
         public static ParseCamera(parsedCamera: any, scene: Scene): Camera {
             var camera;
             var position = Vector3.FromArray(parsedCamera.position);
             var lockedTargetMesh = (parsedCamera.lockedTargetId) ? scene.getLastMeshByID(parsedCamera.lockedTargetId) : null;
+            var interaxial_distance: number;
 
             if (parsedCamera.type === "AnaglyphArcRotateCamera" || parsedCamera.type === "ArcRotateCamera") {
                 var alpha = parsedCamera.alpha;
                 var beta = parsedCamera.beta;
                 var radius = parsedCamera.radius;
                 if (parsedCamera.type === "AnaglyphArcRotateCamera") {
-                    var interaxial_distance = parsedCamera.interaxial_distance;
+                    interaxial_distance = parsedCamera.interaxial_distance;
                     camera = new AnaglyphArcRotateCamera(parsedCamera.name, alpha, beta, radius, lockedTargetMesh, interaxial_distance, scene);
                 } else {
                     camera = new ArcRotateCamera(parsedCamera.name, alpha, beta, radius, lockedTargetMesh, scene);

src/Cameras/babylon.deviceOrientationCamera.js

@@ -44,7 +44,7 @@ var BABYLON;
             window.addEventListener("deviceorientation", this._orientationChanged);
         };
         DeviceOrientationCamera.prototype.detachControl = function (canvas) {
-            if (this._attachedCanvas != canvas) {
+            if (this._attachedCanvas !== canvas) {
                 return;
             }
             window.removeEventListener("deviceorientation", this._orientationChanged);

src/Cameras/babylon.deviceOrientationCamera.ts

@@ -47,7 +47,7 @@ module BABYLON {
         }
 
         public detachControl(canvas: HTMLCanvasElement): void {
-            if (this._attachedCanvas != canvas) {
+            if (this._attachedCanvas !== canvas) {
                 return;
             }
 

src/Cameras/babylon.followCamera.js

@@ -55,6 +55,13 @@ var BABYLON;
             _super.prototype._checkInputs.call(this);
             this.follow(this.target);
         };
+        FollowCamera.prototype.serialize = function () {
+            var serializationObject = _super.prototype.serialize.call(this);
+            serializationObject.radius = this.radius;
+            serializationObject.heightOffset = this.heightOffset;
+            serializationObject.rotationOffset = this.rotationOffset;
+            return serializationObject;
+        };
         return FollowCamera;
     })(BABYLON.TargetCamera);
     BABYLON.FollowCamera = FollowCamera;
@@ -80,6 +87,11 @@ var BABYLON;
             _super.prototype._checkInputs.call(this);
             this.follow();
         };
+        ArcFollowCamera.prototype.serialize = function () {
+            var serializationObject = _super.prototype.serialize.call(this);
+            serializationObject.radius = this.radius;
+            return serializationObject;
+        };
         return ArcFollowCamera;
     })(BABYLON.TargetCamera);
     BABYLON.ArcFollowCamera = ArcFollowCamera;

src/Cameras/babylon.followCamera.ts

@@ -59,6 +59,16 @@
             super._checkInputs();
             this.follow(this.target);
         }
+
+        public serialize(): any {
+            var serializationObject = super.serialize();
+       
+            serializationObject.radius = this.radius;
+            serializationObject.heightOffset = this.heightOffset;
+            serializationObject.rotationOffset = this.rotationOffset;
+       
+            return serializationObject;
+        }
     }
 
     export class ArcFollowCamera extends TargetCamera {
@@ -83,6 +93,14 @@
             super._checkInputs();
             this.follow();
         }
+
+        public serialize(): any {
+            var serializationObject = super.serialize();
+
+            serializationObject.radius = this.radius;
+
+            return serializationObject;
+        }
     }
 }
 

src/Cameras/babylon.freeCamera.js

@@ -222,6 +222,13 @@ var BABYLON;
                 this.position.addInPlace(this.cameraDirection);
             }
         };
+        FreeCamera.prototype.serialize = function () {
+            var serializationObject = _super.prototype.serialize.call(this);
+            serializationObject.checkCollisions = this.checkCollisions;
+            serializationObject.applyGravity = this.applyGravity;
+            serializationObject.ellipsoid = this.ellipsoid.asArray();
+            return serializationObject;
+        };
         return FreeCamera;
     })(BABYLON.TargetCamera);
     BABYLON.FreeCamera = FreeCamera;

src/Cameras/babylon.freeCamera.ts

@@ -264,5 +264,15 @@
                 this.position.addInPlace(this.cameraDirection);
             }
         }
+
+        public serialize(): any {
+            var serializationObject = super.serialize();
+
+            serializationObject.checkCollisions = this.checkCollisions;
+            serializationObject.applyGravity = this.applyGravity;
+            serializationObject.ellipsoid = this.ellipsoid.asArray();
+
+            return serializationObject;
+        }
     }
 } 

src/Cameras/babylon.stereoscopicCameras.js

@@ -9,6 +9,7 @@ var BABYLON;
         __extends(AnaglyphFreeCamera, _super);
         function AnaglyphFreeCamera(name, position, interaxialDistance, scene) {
             _super.call(this, name, position, scene);
+            this.interaxialDistance = interaxialDistance;
             this.setCameraRigMode(BABYLON.Camera.RIG_MODE_STEREOSCOPIC_ANAGLYPH, { interaxialDistance: interaxialDistance });
         }
         return AnaglyphFreeCamera;

src/Cameras/babylon.stereoscopicCameras.ts

@@ -1,6 +1,6 @@
 module BABYLON {
     export class AnaglyphFreeCamera extends FreeCamera {
-        constructor(name: string, position: Vector3, interaxialDistance: number, scene: Scene) {
+        constructor(name: string, position: Vector3, public interaxialDistance: number, scene: Scene) {
             super(name, position, scene);
             this.setCameraRigMode(Camera.RIG_MODE_STEREOSCOPIC_ANAGLYPH, { interaxialDistance: interaxialDistance });
         }

src/Cameras/babylon.targetCamera.js

@@ -240,6 +240,17 @@ var BABYLON;
             this._rigCamTransformMatrix = this._rigCamTransformMatrix.multiply(BABYLON.Matrix.Translation(target.x, target.y, target.z));
             BABYLON.Vector3.TransformCoordinatesToRef(this.position, this._rigCamTransformMatrix, result);
         };
+        TargetCamera.prototype.serialize = function () {
+            var serializationObject = _super.prototype.serialize.call(this);
+            serializationObject.speed = this.speed;
+            if (this.rotation) {
+                serializationObject.rotation = this.rotation.asArray();
+            }
+            if (this.lockedTarget && this.lockedTarget.id) {
+                serializationObject.lockedTargetId = this.lockedTarget.id;
+            }
+            return serializationObject;
+        };
         return TargetCamera;
     })(BABYLON.Camera);
     BABYLON.TargetCamera = TargetCamera;

src/Cameras/babylon.targetCamera.ts

@@ -296,5 +296,20 @@
 
             Vector3.TransformCoordinatesToRef(this.position, this._rigCamTransformMatrix, result);
         }
+
+        public serialize(): any {
+            var serializationObject = super.serialize();
+            serializationObject.speed = this.speed;
+
+            if (this.rotation) {
+                serializationObject.rotation = this.rotation.asArray();
+            }
+
+            if (this.lockedTarget && this.lockedTarget.id) {
+                serializationObject.lockedTargetId = this.lockedTarget.id;
+            }
+
+            return serializationObject;
+        }
     }
 } 

src/LensFlare/babylon.lensFlareSystem.js

@@ -186,6 +186,22 @@ var BABYLON;
             }
             return lensFlareSystem;
         };
+        LensFlareSystem.prototype.serialize = function () {
+            var serializationObject = {};
+            serializationObject.emitterId = this.getEmitter().id;
+            serializationObject.borderLimit = this.borderLimit;
+            serializationObject.flares = [];
+            for (var index = 0; index < this.lensFlares.length; index++) {
+                var flare = this.lensFlares[index];
+                serializationObject.flares.push({
+                    size: flare.size,
+                    position: flare.position,
+                    color: flare.color.asArray(),
+                    textureName: BABYLON.Tools.GetFilename(flare.texture.name)
+                });
+            }
+            return serializationObject;
+        };
         return LensFlareSystem;
     })();
     BABYLON.LensFlareSystem = LensFlareSystem;

src/LensFlare/babylon.lensFlareSystem.ts

@@ -247,5 +247,26 @@
 
             return lensFlareSystem;
         }
+
+        public serialize(): any {
+            var serializationObject: any = {};
+
+            serializationObject.emitterId = this.getEmitter().id;
+            serializationObject.borderLimit = this.borderLimit;
+
+            serializationObject.flares = [];
+            for (var index = 0; index < this.lensFlares.length; index++) {
+                var flare = this.lensFlares[index];
+
+                serializationObject.flares.push({
+                    size: flare.size,
+                    position: flare.position,
+                    color: flare.color.asArray(),
+                    textureName: Tools.GetFilename(flare.texture.name)
+                });
+            }
+
+            return serializationObject;
+        }
     }
 } 

src/Lights/Shadows/babylon.shadowGenerator.js

@@ -338,6 +338,19 @@ var BABYLON;
                 this._boxBlurPostprocess.dispose();
             }
         };
+        ShadowGenerator.prototype.serialize = function () {
+            var serializationObject = {};
+            serializationObject.lightId = this._light.id;
+            serializationObject.mapSize = this.getShadowMap().getRenderSize();
+            serializationObject.useVarianceShadowMap = this.useVarianceShadowMap;
+            serializationObject.usePoissonSampling = this.usePoissonSampling;
+            serializationObject.renderList = [];
+            for (var meshIndex = 0; meshIndex < this.getShadowMap().renderList.length; meshIndex++) {
+                var mesh = this.getShadowMap().renderList[meshIndex];
+                serializationObject.renderList.push(mesh.id);
+            }
+            return serializationObject;
+        };
         ShadowGenerator.ParseShadowGenerator = function (parsedShadowGenerator, scene) {
             //casting to point light, as light is missing the position attr and typescript complains.
             var light = scene.getLightByID(parsedShadowGenerator.lightId);

src/Lights/Shadows/babylon.shadowGenerator.ts

@@ -392,9 +392,27 @@
             }
         }
 
+        public serialize(): any {
+            var serializationObject: any = {};
+
+            serializationObject.lightId = this._light.id;
+            serializationObject.mapSize = this.getShadowMap().getRenderSize();
+            serializationObject.useVarianceShadowMap = this.useVarianceShadowMap;
+            serializationObject.usePoissonSampling = this.usePoissonSampling;
+
+            serializationObject.renderList = [];
+            for (var meshIndex = 0; meshIndex < this.getShadowMap().renderList.length; meshIndex++) {
+                var mesh = this.getShadowMap().renderList[meshIndex];
+
+                serializationObject.renderList.push(mesh.id);
+            }
+
+            return serializationObject;
+        }
+
         public static ParseShadowGenerator(parsedShadowGenerator: any, scene: Scene): ShadowGenerator {
             //casting to point light, as light is missing the position attr and typescript complains.
-            var light = <PointLight> scene.getLightByID(parsedShadowGenerator.lightId);
+            var light = <PointLight>scene.getLightByID(parsedShadowGenerator.lightId);
             var shadowGenerator = new ShadowGenerator(parsedShadowGenerator.mapSize, light);
 
             for (var meshIndex = 0; meshIndex < parsedShadowGenerator.renderList.length; meshIndex++) {

src/Lights/babylon.directionalLight.js

@@ -102,6 +102,13 @@ var BABYLON;
             BABYLON.Matrix.TranslationToRef(this.position.x, this.position.y, this.position.z, this._worldMatrix);
             return this._worldMatrix;
         };
+        DirectionalLight.prototype.serialize = function () {
+            var serializationObject = _super.prototype.serialize.call(this);
+            serializationObject.type = 1;
+            serializationObject.position = this.position.asArray();
+            serializationObject.direction = this.direction.asArray();
+            return serializationObject;
+        };
         return DirectionalLight;
     })(BABYLON.Light);
     BABYLON.DirectionalLight = DirectionalLight;

src/Lights/babylon.directionalLight.ts

@@ -135,5 +135,14 @@
 
             return this._worldMatrix;
         }
+
+        public serialize(): any {
+            var serializationObject = super.serialize();
+            serializationObject.type = 1;
+            serializationObject.position = this.position.asArray();
+            serializationObject.direction = this.direction.asArray();
+
+            return serializationObject;
+        }
     }
 }  

src/Lights/babylon.hemisphericLight.js

@@ -30,6 +30,13 @@ var BABYLON;
             }
             return this._worldMatrix;
         };
+        HemisphericLight.prototype.serialize = function () {
+            var serializationObject = _super.prototype.serialize.call(this);
+            serializationObject.type = 3;
+            serializationObject.direction = this.direction.asArray();
+            serializationObject.groundColor = this.groundColor.asArray();
+            return serializationObject;
+        };
         return HemisphericLight;
     })(BABYLON.Light);
     BABYLON.HemisphericLight = HemisphericLight;

src/Lights/babylon.hemisphericLight.ts

@@ -30,5 +30,14 @@
 
             return this._worldMatrix;
         }
+
+        public serialize(): any {
+            var serializationObject = super.serialize();
+            serializationObject.type = 3;
+            serializationObject.direction = this.direction.asArray();
+            serializationObject.groundColor = this.groundColor.asArray();
+
+            return serializationObject;
+        }
     }
 } 

src/Lights/babylon.light.js

@@ -73,6 +73,19 @@ var BABYLON;
             // Remove from scene
             this.getScene().removeLight(this);
         };
+        Light.prototype.serialize = function () {
+            var serializationObject = {};
+            serializationObject.name = this.name;
+            serializationObject.id = this.id;
+            serializationObject.tags = BABYLON.Tags.GetTags(this);
+            if (this.intensity) {
+                serializationObject.intensity = this.intensity;
+            }
+            serializationObject.range = this.range;
+            serializationObject.diffuse = this.diffuse.asArray();
+            serializationObject.specular = this.specular.asArray();
+            return serializationObject;
+        };
         Light.ParseLight = function (parsedLight, scene) {
             var light;
             switch (parsedLight.type) {

src/Lights/babylon.light.ts

@@ -1,6 +1,7 @@
 module BABYLON {
 
     export interface IShadowLight {
+        id: string;
         position: Vector3;
         transformedPosition: Vector3;
         name: string;
@@ -113,6 +114,24 @@
             this.getScene().removeLight(this);
         }
 
+        public serialize(): any {
+            var serializationObject: any = {};
+            serializationObject.name = this.name;
+            serializationObject.id = this.id;
+            serializationObject.tags = Tags.GetTags(this);
+
+            if (this.intensity) {
+                serializationObject.intensity = this.intensity;
+            }
+
+            serializationObject.range = this.range;
+
+            serializationObject.diffuse = this.diffuse.asArray();
+            serializationObject.specular = this.specular.asArray();
+
+            return serializationObject;
+        }
+
         public static ParseLight(parsedLight: any, scene: Scene): Light {
             var light;
 

src/Lights/babylon.pointLight.js

@@ -69,6 +69,12 @@ var BABYLON;
             BABYLON.Matrix.TranslationToRef(this.position.x, this.position.y, this.position.z, this._worldMatrix);
             return this._worldMatrix;
         };
+        PointLight.prototype.serialize = function () {
+            var serializationObject = _super.prototype.serialize.call(this);
+            serializationObject.type = 0;
+            serializationObject.position = this.position.asArray();
+            return serializationObject;
+        };
         return PointLight;
     })(BABYLON.Light);
     BABYLON.PointLight = PointLight;

src/Lights/babylon.pointLight.ts

@@ -82,5 +82,14 @@
 
             return this._worldMatrix;
         }
+
+        public serialize(): any {
+            var serializationObject = super.serialize();
+
+            serializationObject.type = 0;
+            serializationObject.position = this.position.asArray();
+
+            return serializationObject;
+        }
     }
 } 

src/Lights/babylon.spotLight.js

@@ -71,6 +71,15 @@ var BABYLON;
             BABYLON.Matrix.TranslationToRef(this.position.x, this.position.y, this.position.z, this._worldMatrix);
             return this._worldMatrix;
         };
+        SpotLight.prototype.serialize = function () {
+            var serializationObject = _super.prototype.serialize.call(this);
+            serializationObject.type = 2;
+            serializationObject.position = this.position.asArray();
+            serializationObject.direction = this.position.asArray();
+            serializationObject.angle = this.angle;
+            serializationObject.exponent = this.exponent;
+            return serializationObject;
+        };
         return SpotLight;
     })(BABYLON.Light);
     BABYLON.SpotLight = SpotLight;

src/Lights/babylon.spotLight.ts

@@ -84,5 +84,17 @@
 
             return this._worldMatrix;
         }
+
+        public serialize(): any {
+            var serializationObject = super.serialize();
+
+            serializationObject.type = 2;
+            serializationObject.position = this.position.asArray();
+            serializationObject.direction = this.position.asArray();
+            serializationObject.angle = this.angle;
+            serializationObject.exponent = this.exponent;
+
+            return serializationObject;
+        }
     }
 }

src/Loading/Plugins/babylon.babylonFileLoader.js

@@ -128,7 +128,7 @@ var BABYLON;
                                 }
                             }
                         }
-                        var mesh = mesh.ParseMesh(parsedMesh, scene, rootUrl);
+                        var mesh = BABYLON.Mesh.ParseMesh(parsedMesh, scene, rootUrl);
                         meshes.push(mesh);
                     }
                 }

src/Loading/Plugins/babylon.babylonFileLoader.ts

@@ -142,7 +142,7 @@
                         }
                     }
 
-                    var mesh = mesh.ParseMesh(parsedMesh, scene, rootUrl);
+                    var mesh = Mesh.ParseMesh(parsedMesh, scene, rootUrl);
                     meshes.push(mesh);
                 }
             }

src/Materials/babylon.multiMaterial.js

@@ -39,6 +39,23 @@ var BABYLON;
             }
             return newMultiMaterial;
         };
+        MultiMaterial.prototype.serialize = function () {
+            var serializationObject = {};
+            serializationObject.name = this.name;
+            serializationObject.id = this.id;
+            serializationObject.tags = BABYLON.Tags.GetTags(this);
+            serializationObject.materials = [];
+            for (var matIndex = 0; matIndex < this.subMaterials.length; matIndex++) {
+                var subMat = this.subMaterials[matIndex];
+                if (subMat) {
+                    serializationObject.materials.push(subMat.id);
+                }
+                else {
+                    serializationObject.materials.push(null);
+                }
+            }
+            return serializationObject;
+        };
         MultiMaterial.ParseMultiMaterial = function (parsedMultiMaterial, scene) {
             var multiMaterial = new BABYLON.MultiMaterial(parsedMultiMaterial.name, scene);
             multiMaterial.id = parsedMultiMaterial.id;

src/Materials/babylon.multiMaterial.ts

@@ -42,6 +42,28 @@
             return newMultiMaterial;
         }
 
+        public serialize(): any {
+            var serializationObject: any = {};
+
+            serializationObject.name = this.name;
+            serializationObject.id = this.id;
+            serializationObject.tags = Tags.GetTags(this);
+
+            serializationObject.materials = [];
+
+            for (var matIndex = 0; matIndex < this.subMaterials.length; matIndex++) {
+                var subMat = this.subMaterials[matIndex];
+
+                if (subMat) {
+                    serializationObject.materials.push(subMat.id);
+                } else {
+                    serializationObject.materials.push(null);
+                }
+            }
+
+            return serializationObject;
+        }
+
         public static ParseMultiMaterial(parsedMultiMaterial: any, scene: Scene): MultiMaterial {
             var multiMaterial = new BABYLON.MultiMaterial(parsedMultiMaterial.name, scene);
 

src/Particles/babylon.particleSystem.js

@@ -157,12 +157,13 @@ var BABYLON;
             else {
                 worldMatrix = BABYLON.Matrix.Translation(this.emitter.x, this.emitter.y, this.emitter.z);
             }
+            var particle;
             for (var index = 0; index < newParticles; index++) {
                 if (this.particles.length === this._capacity) {
                     break;
                 }
                 if (this._stockParticles.length !== 0) {
-                    var particle = this._stockParticles.pop();
+                    particle = this._stockParticles.pop();
                     particle.age = 0;
                 }
                 else {
@@ -328,6 +329,34 @@ var BABYLON;
             result.start();
             return result;
         };
+        ParticleSystem.prototype.serialize = function () {
+            var serializationObject = {};
+            serializationObject.emitterId = this.emitter.id;
+            serializationObject.capacity = this.getCapacity();
+            if (this.particleTexture) {
+                serializationObject.textureName = this.particleTexture.name;
+            }
+            serializationObject.minAngularSpeed = this.minAngularSpeed;
+            serializationObject.maxAngularSpeed = this.maxAngularSpeed;
+            serializationObject.minSize = this.minSize;
+            serializationObject.maxSize = this.maxSize;
+            serializationObject.minLifeTime = this.minLifeTime;
+            serializationObject.maxLifeTime = this.maxLifeTime;
+            serializationObject.emitRate = this.emitRate;
+            serializationObject.minEmitBox = this.minEmitBox.asArray();
+            serializationObject.maxEmitBox = this.maxEmitBox.asArray();
+            serializationObject.gravity = this.gravity.asArray();
+            serializationObject.direction1 = this.direction1.asArray();
+            serializationObject.direction2 = this.direction2.asArray();
+            serializationObject.color1 = this.color1.asArray();
+            serializationObject.color2 = this.color2.asArray();
+            serializationObject.colorDead = this.colorDead.asArray();
+            serializationObject.updateSpeed = this.updateSpeed;
+            serializationObject.targetStopDuration = this.targetStopDuration;
+            serializationObject.textureMask = this.textureMask.asArray();
+            serializationObject.blendMode = this.blendMode;
+            return serializationObject;
+        };
         ParticleSystem.ParseParticleSystem = function (parsedParticleSystem, scene, rootUrl) {
             var emitter = scene.getLastMeshByID(parsedParticleSystem.emitterId);
             var particleSystem = new ParticleSystem("particles#" + emitter.name, parsedParticleSystem.capacity, scene);

src/Particles/babylon.particleSystem.ts

@@ -220,14 +220,14 @@
             } else {
                 worldMatrix = Matrix.Translation(this.emitter.x, this.emitter.y, this.emitter.z);
             }
-
+            var particle: Particle;
             for (var index = 0; index < newParticles; index++) {
                 if (this.particles.length === this._capacity) {
                     break;
                 }
 
                 if (this._stockParticles.length !== 0) {
-                    var particle = this._stockParticles.pop();
+                    particle = this._stockParticles.pop();
                     particle.age = 0;
                 } else {
                     particle = new Particle();
@@ -446,6 +446,39 @@
             return result;
         }
 
+        public serialize(): any {
+            var serializationObject: any = {};
+
+            serializationObject.emitterId = this.emitter.id;
+            serializationObject.capacity = this.getCapacity();
+
+            if (this.particleTexture) {
+                serializationObject.textureName = this.particleTexture.name;
+            }
+
+            serializationObject.minAngularSpeed = this.minAngularSpeed;
+            serializationObject.maxAngularSpeed = this.maxAngularSpeed;
+            serializationObject.minSize = this.minSize;
+            serializationObject.maxSize = this.maxSize;
+            serializationObject.minLifeTime = this.minLifeTime;
+            serializationObject.maxLifeTime = this.maxLifeTime;
+            serializationObject.emitRate = this.emitRate;
+            serializationObject.minEmitBox = this.minEmitBox.asArray();
+            serializationObject.maxEmitBox = this.maxEmitBox.asArray();
+            serializationObject.gravity = this.gravity.asArray();
+            serializationObject.direction1 = this.direction1.asArray();
+            serializationObject.direction2 = this.direction2.asArray();
+            serializationObject.color1 = this.color1.asArray();
+            serializationObject.color2 = this.color2.asArray();
+            serializationObject.colorDead = this.colorDead.asArray();
+            serializationObject.updateSpeed = this.updateSpeed;
+            serializationObject.targetStopDuration = this.targetStopDuration;
+            serializationObject.textureMask = this.textureMask.asArray();
+            serializationObject.blendMode = this.blendMode;
+
+            return serializationObject;
+        }
+
         public static ParseParticleSystem(parsedParticleSystem: any, scene: Scene, rootUrl: string): ParticleSystem {
             var emitter = scene.getLastMeshByID(parsedParticleSystem.emitterId);
 

src/Tools/babylon.sceneSerializer.js

@@ -1,232 +1,5 @@
 var BABYLON;
 (function (BABYLON) {
-    var serializeLight = function (light) {
-        var serializationObject = {};
-        serializationObject.name = light.name;
-        serializationObject.id = light.id;
-        serializationObject.tags = BABYLON.Tags.GetTags(light);
-        if (light instanceof BABYLON.PointLight) {
-            serializationObject.type = 0;
-            serializationObject.position = (light).position.asArray();
-        }
-        else if (light instanceof BABYLON.DirectionalLight) {
-            serializationObject.type = 1;
-            var directionalLight = light;
-            serializationObject.position = directionalLight.position.asArray();
-            serializationObject.direction = directionalLight.direction.asArray();
-        }
-        else if (light instanceof BABYLON.SpotLight) {
-            serializationObject.type = 2;
-            var spotLight = light;
-            serializationObject.position = spotLight.position.asArray();
-            serializationObject.direction = spotLight.position.asArray();
-            serializationObject.angle = spotLight.angle;
-            serializationObject.exponent = spotLight.exponent;
-        }
-        else if (light instanceof BABYLON.HemisphericLight) {
-            serializationObject.type = 3;
-            var hemisphericLight = light;
-            serializationObject.direction = hemisphericLight.direction.asArray();
-            serializationObject.groundColor = hemisphericLight.groundColor.asArray();
-        }
-        if (light.intensity) {
-            serializationObject.intensity = light.intensity;
-        }
-        serializationObject.range = light.range;
-        serializationObject.diffuse = light.diffuse.asArray();
-        serializationObject.specular = light.specular.asArray();
-        return serializationObject;
-    };
-    var serializeCamera = function (camera) {
-        var serializationObject = {};
-        serializationObject.name = camera.name;
-        serializationObject.tags = BABYLON.Tags.GetTags(camera);
-        serializationObject.id = camera.id;
-        serializationObject.position = camera.position.asArray();
-        // Parent
-        if (camera.parent) {
-            serializationObject.parentId = camera.parent.id;
-        }
-        serializationObject.fov = camera.fov;
-        serializationObject.minZ = camera.minZ;
-        serializationObject.maxZ = camera.maxZ;
-        serializationObject.inertia = camera.inertia;
-        //setting the type
-        if (camera instanceof BABYLON.FreeCamera) {
-            serializationObject.type = "FreeCamera";
-        }
-        else if (camera instanceof BABYLON.ArcRotateCamera) {
-            serializationObject.type = "ArcRotateCamera";
-        }
-        else if (camera instanceof BABYLON.AnaglyphArcRotateCamera) {
-            serializationObject.type = "AnaglyphArcRotateCamera";
-        }
-        else if (camera instanceof BABYLON.GamepadCamera) {
-            serializationObject.type = "GamepadCamera";
-        }
-        else if (camera instanceof BABYLON.AnaglyphFreeCamera) {
-            serializationObject.type = "AnaglyphFreeCamera";
-        }
-        else if (camera instanceof BABYLON.DeviceOrientationCamera) {
-            serializationObject.type = "DeviceOrientationCamera";
-        }
-        else if (camera instanceof BABYLON.FollowCamera) {
-            serializationObject.type = "FollowCamera";
-        }
-        else if (camera instanceof BABYLON.TouchCamera) {
-            serializationObject.type = "TouchCamera";
-        }
-        else if (camera instanceof BABYLON.VirtualJoysticksCamera) {
-            serializationObject.type = "VirtualJoysticksCamera";
-        }
-        else if (camera instanceof BABYLON.WebVRFreeCamera) {
-            serializationObject.type = "WebVRFreeCamera";
-        }
-        else if (camera instanceof BABYLON.VRDeviceOrientationFreeCamera) {
-            serializationObject.type = "VRDeviceOrientationFreeCamera";
-        }
-        //special properties of specific cameras
-        if (camera instanceof BABYLON.ArcRotateCamera || camera instanceof BABYLON.AnaglyphArcRotateCamera) {
-            var arcCamera = camera;
-            serializationObject.alpha = arcCamera.alpha;
-            serializationObject.beta = arcCamera.beta;
-            serializationObject.radius = arcCamera.radius;
-            if (arcCamera.target && arcCamera.target.id) {
-                serializationObject.lockedTargetId = arcCamera.target.id;
-            }
-        }
-        else if (camera instanceof BABYLON.FollowCamera) {
-            var followCam = camera;
-            serializationObject.radius = followCam.radius;
-            serializationObject.heightOffset = followCam.heightOffset;
-            serializationObject.rotationOffset = followCam.rotationOffset;
-        }
-        else if (camera instanceof BABYLON.AnaglyphFreeCamera || camera instanceof BABYLON.AnaglyphArcRotateCamera) {
-            //eye space is a private member and can only be access like this. Without changing the implementation this is the best way to get it.
-            if (camera['_interaxialDistance'] !== undefined) {
-                serializationObject.interaxial_distance = BABYLON.Tools.ToDegrees(camera['_interaxialDistance']);
-            }
-        }
-        //general properties that not all cameras have. The [] is due to typescript's type safety
-        if (camera['speed'] !== undefined) {
-            serializationObject.speed = camera['speed'];
-        }
-        if (camera['target'] && camera['target'] instanceof BABYLON.Vector3) {
-            serializationObject.target = camera['target'].asArray();
-        }
-        // Target
-        if (camera['rotation'] && camera['rotation'] instanceof BABYLON.Vector3) {
-            serializationObject.rotation = camera['rotation'].asArray();
-        }
-        // Locked target
-        if (camera['lockedTarget'] && camera['lockedTarget'].id) {
-            serializationObject.lockedTargetId = camera['lockedTarget'].id;
-        }
-        serializationObject.checkCollisions = camera['checkCollisions'] || false;
-        serializationObject.applyGravity = camera['applyGravity'] || false;
-        if (camera['ellipsoid']) {
-            serializationObject.ellipsoid = camera['ellipsoid'].asArray();
-        }
-        // Animations
-        BABYLON.Animation.AppendSerializedAnimations(camera, serializationObject);
-        // Layer mask
-        serializationObject.layerMask = camera.layerMask;
-        return serializationObject;
-    };
-    var serializeMultiMaterial = function (material) {
-        var serializationObject = {};
-        serializationObject.name = material.name;
-        serializationObject.id = material.id;
-        serializationObject.tags = BABYLON.Tags.GetTags(material);
-        serializationObject.materials = [];
-        for (var matIndex = 0; matIndex < material.subMaterials.length; matIndex++) {
-            var subMat = material.subMaterials[matIndex];
-            if (subMat) {
-                serializationObject.materials.push(subMat.id);
-            }
-            else {
-                serializationObject.materials.push(null);
-            }
-        }
-        return serializationObject;
-    };
-    var serializeSkeleton = function (skeleton) {
-        var serializationObject = {};
-        serializationObject.name = skeleton.name;
-        serializationObject.id = skeleton.id;
-        serializationObject.bones = [];
-        for (var index = 0; index < skeleton.bones.length; index++) {
-            var bone = skeleton.bones[index];
-            var serializedBone = {
-                parentBoneIndex: bone.getParent() ? skeleton.bones.indexOf(bone.getParent()) : -1,
-                name: bone.name,
-                matrix: bone.getLocalMatrix().toArray()
-            };
-            serializationObject.bones.push(serializedBone);
-            if (bone.animations && bone.animations.length > 0) {
-                serializedBone.animation = bone.animations[0].serialize();
-            }
-        }
-        return serializationObject;
-    };
-    var serializeParticleSystem = function (particleSystem) {
-        var serializationObject = {};
-        serializationObject.emitterId = particleSystem.emitter.id;
-        serializationObject.capacity = particleSystem.getCapacity();
-        if (particleSystem.particleTexture) {
-            serializationObject.textureName = particleSystem.particleTexture.name;
-        }
-        serializationObject.minAngularSpeed = particleSystem.minAngularSpeed;
-        serializationObject.maxAngularSpeed = particleSystem.maxAngularSpeed;
-        serializationObject.minSize = particleSystem.minSize;
-        serializationObject.maxSize = particleSystem.maxSize;
-        serializationObject.minLifeTime = particleSystem.minLifeTime;
-        serializationObject.maxLifeTime = particleSystem.maxLifeTime;
-        serializationObject.emitRate = particleSystem.emitRate;
-        serializationObject.minEmitBox = particleSystem.minEmitBox.asArray();
-        serializationObject.maxEmitBox = particleSystem.maxEmitBox.asArray();
-        serializationObject.gravity = particleSystem.gravity.asArray();
-        serializationObject.direction1 = particleSystem.direction1.asArray();
-        serializationObject.direction2 = particleSystem.direction2.asArray();
-        serializationObject.color1 = particleSystem.color1.asArray();
-        serializationObject.color2 = particleSystem.color2.asArray();
-        serializationObject.colorDead = particleSystem.colorDead.asArray();
-        serializationObject.updateSpeed = particleSystem.updateSpeed;
-        serializationObject.targetStopDuration = particleSystem.targetStopDuration;
-        serializationObject.textureMask = particleSystem.textureMask.asArray();
-        serializationObject.blendMode = particleSystem.blendMode;
-        return serializationObject;
-    };
-    var serializeLensFlareSystem = function (lensFlareSystem) {
-        var serializationObject = {};
-        serializationObject.emitterId = lensFlareSystem.getEmitter().id;
-        serializationObject.borderLimit = lensFlareSystem.borderLimit;
-        serializationObject.flares = [];
-        for (var index = 0; index < lensFlareSystem.lensFlares.length; index++) {
-            var flare = lensFlareSystem.lensFlares[index];
-            serializationObject.flares.push({
-                size: flare.size,
-                position: flare.position,
-                color: flare.color.asArray(),
-                textureName: BABYLON.Tools.GetFilename(flare.texture.name)
-            });
-        }
-        return serializationObject;
-    };
-    var serializeShadowGenerator = function (light) {
-        var serializationObject = {};
-        var shadowGenerator = light.getShadowGenerator();
-        serializationObject.lightId = light.id;
-        serializationObject.mapSize = shadowGenerator.getShadowMap().getRenderSize();
-        serializationObject.useVarianceShadowMap = shadowGenerator.useVarianceShadowMap;
-        serializationObject.usePoissonSampling = shadowGenerator.usePoissonSampling;
-        serializationObject.renderList = [];
-        for (var meshIndex = 0; meshIndex < shadowGenerator.getShadowMap().renderList.length; meshIndex++) {
-            var mesh = shadowGenerator.getShadowMap().renderList[meshIndex];
-            serializationObject.renderList.push(mesh.id);
-        }
-        return serializationObject;
-    };
     var serializedGeometries = [];
     var serializeVertexData;
     var serializeTorusKnot;
@@ -479,7 +252,7 @@ var BABYLON;
                 else if (mesh.material instanceof BABYLON.MultiMaterial) {
                     serializationObject.multiMaterials = serializationObject.multiMaterials || [];
                     if (!serializationObject.multiMaterials.some(function (mat) { return (mat.id === mesh.material.id); })) {
-                        serializationObject.multiMaterials.push(serializeMultiMaterial(mesh.material));
+                        serializationObject.multiMaterials.push(mesh.material.serialize());
                     }
                 }
             }
@@ -502,7 +275,7 @@ var BABYLON;
             // Skeletons
             if (mesh.skeleton) {
                 serializationObject.skeletons = serializationObject.skeletons || [];
-                serializationObject.skeletons.push(serializeSkeleton(mesh.skeleton));
+                serializationObject.skeletons.push(mesh.skeleton.serialize());
             }
             //serialize the actual mesh
             serializationObject.meshes = serializationObject.meshes || [];
@@ -542,13 +315,13 @@ var BABYLON;
             var light;
             for (index = 0; index < scene.lights.length; index++) {
                 light = scene.lights[index];
-                serializationObject.lights.push(serializeLight(light));
+                serializationObject.lights.push(light.serialize());
             }
             // Cameras
             serializationObject.cameras = [];
             for (index = 0; index < scene.cameras.length; index++) {
                 var camera = scene.cameras[index];
-                serializationObject.cameras.push(serializeCamera(camera));
+                serializationObject.cameras.push(camera.serialize());
             }
             if (scene.activeCamera) {
                 serializationObject.activeCameraID = scene.activeCamera.id;
@@ -565,21 +338,16 @@ var BABYLON;
             serializationObject.multiMaterials = [];
             for (index = 0; index < scene.multiMaterials.length; index++) {
                 var multiMaterial = scene.multiMaterials[index];
-                serializationObject.multiMaterials.push(serializeMultiMaterial(multiMaterial));
+                serializationObject.multiMaterials.push(multiMaterial.serialize());
             }
             for (index = 0; index < scene.materials.length; index++) {
                 material = scene.materials[index];
-                if (material instanceof BABYLON.StandardMaterial) {
-                    serializationObject.materials.push(material.serialize());
-                }
-                else if (material instanceof BABYLON.MultiMaterial) {
-                    serializationObject.multiMaterials.push(serializeMultiMaterial(material));
-                }
+                serializationObject.materials.push(material.serialize());
             }
             // Skeletons
             serializationObject.skeletons = [];
             for (index = 0; index < scene.skeletons.length; index++) {
-                serializationObject.skeletons.push(serializeSkeleton(scene.skeletons[index]));
+                serializationObject.skeletons.push(scene.skeletons[index].serialize());
             }
             // Geometries
             serializationObject.geometries = {};
@@ -613,19 +381,19 @@ var BABYLON;
             // Particles Systems
             serializationObject.particleSystems = [];
             for (index = 0; index < scene.particleSystems.length; index++) {
-                serializationObject.particleSystems.push(serializeParticleSystem(scene.particleSystems[index]));
+                serializationObject.particleSystems.push(scene.particleSystems[index].serialize());
             }
             // Lens flares
             serializationObject.lensFlareSystems = [];
             for (index = 0; index < scene.lensFlareSystems.length; index++) {
-                serializationObject.lensFlareSystems.push(serializeLensFlareSystem(scene.lensFlareSystems[index]));
+                serializationObject.lensFlareSystems.push(scene.lensFlareSystems[index].serialize());
             }
             // Shadows
             serializationObject.shadowGenerators = [];
             for (index = 0; index < scene.lights.length; index++) {
                 light = scene.lights[index];
                 if (light.getShadowGenerator()) {
-                    serializationObject.shadowGenerators.push(serializeShadowGenerator(light));
+                    serializationObject.shadowGenerators.push(light.getShadowGenerator().serialize());
                 }
             }
             return serializationObject;

src/Tools/babylon.sceneSerializer.ts

@@ -1,266 +1,4 @@
-module BABYLON {
-
-    var serializeLight = (light: Light): any => {
-        var serializationObject: any = {};
-        serializationObject.name = light.name;
-        serializationObject.id = light.id;
-        serializationObject.tags = Tags.GetTags(light);
-
-        if (light instanceof PointLight) {
-            serializationObject.type = 0;
-            serializationObject.position = (light).position.asArray();
-        } else if (light instanceof DirectionalLight) {
-            serializationObject.type = 1;
-            var directionalLight = light;
-            serializationObject.position = directionalLight.position.asArray();
-            serializationObject.direction = directionalLight.direction.asArray();
-        } else if (light instanceof SpotLight) {
-            serializationObject.type = 2;
-            var spotLight = light;
-            serializationObject.position = spotLight.position.asArray();
-            serializationObject.direction = spotLight.position.asArray();
-            serializationObject.angle = spotLight.angle;
-            serializationObject.exponent = spotLight.exponent;
-        } else if (light instanceof HemisphericLight) {
-            serializationObject.type = 3;
-            var hemisphericLight = light;
-            serializationObject.direction = hemisphericLight.direction.asArray();
-            serializationObject.groundColor = hemisphericLight.groundColor.asArray();
-        }
-
-        if (light.intensity) {
-            serializationObject.intensity = light.intensity;
-        }
-
-        serializationObject.range = light.range;
-
-        serializationObject.diffuse = light.diffuse.asArray();
-        serializationObject.specular = light.specular.asArray();
-
-        return serializationObject;
-    };
-
-    var serializeCamera = (camera: Camera): any => {
-        var serializationObject: any = {};
-        serializationObject.name = camera.name;
-        serializationObject.tags = Tags.GetTags(camera);
-        serializationObject.id = camera.id;
-        serializationObject.position = camera.position.asArray();
-
-        // Parent
-        if (camera.parent) {
-            serializationObject.parentId = camera.parent.id;
-        }
-
-        serializationObject.fov = camera.fov;
-        serializationObject.minZ = camera.minZ;
-        serializationObject.maxZ = camera.maxZ;
-
-        serializationObject.inertia = camera.inertia;
-
-        //setting the type
-        if (camera instanceof FreeCamera) {
-            serializationObject.type = "FreeCamera";
-        } else if (camera instanceof ArcRotateCamera) {
-            serializationObject.type = "ArcRotateCamera";
-        } else if (camera instanceof AnaglyphArcRotateCamera) {
-            serializationObject.type = "AnaglyphArcRotateCamera";
-        } else if (camera instanceof GamepadCamera) {
-            serializationObject.type = "GamepadCamera";
-        } else if (camera instanceof AnaglyphFreeCamera) {
-            serializationObject.type = "AnaglyphFreeCamera";
-        } else if (camera instanceof DeviceOrientationCamera) {
-            serializationObject.type = "DeviceOrientationCamera";
-        } else if (camera instanceof FollowCamera) {
-            serializationObject.type = "FollowCamera";
-        } else if (camera instanceof TouchCamera) {
-            serializationObject.type = "TouchCamera";
-        } else if (camera instanceof VirtualJoysticksCamera) {
-            serializationObject.type = "VirtualJoysticksCamera";
-        } else if (camera instanceof WebVRFreeCamera) {
-            serializationObject.type = "WebVRFreeCamera";
-        } else if (camera instanceof VRDeviceOrientationFreeCamera) {
-            serializationObject.type = "VRDeviceOrientationFreeCamera";
-        }
-
-        //special properties of specific cameras
-        if (camera instanceof ArcRotateCamera || camera instanceof AnaglyphArcRotateCamera) {
-            var arcCamera = camera;
-            serializationObject.alpha = arcCamera.alpha;
-            serializationObject.beta = arcCamera.beta;
-            serializationObject.radius = arcCamera.radius;
-            if (arcCamera.target && arcCamera.target.id) {
-                serializationObject.lockedTargetId = arcCamera.target.id;
-            }
-        } else if (camera instanceof FollowCamera) {
-            var followCam = camera;
-            serializationObject.radius = followCam.radius;
-            serializationObject.heightOffset = followCam.heightOffset;
-            serializationObject.rotationOffset = followCam.rotationOffset;
-        } else if (camera instanceof AnaglyphFreeCamera || camera instanceof AnaglyphArcRotateCamera) {
-            //eye space is a private member and can only be access like this. Without changing the implementation this is the best way to get it.
-            if (camera['_interaxialDistance'] !== undefined) {
-                serializationObject.interaxial_distance = Tools.ToDegrees(camera['_interaxialDistance']);
-            }
-        }
-
-        //general properties that not all cameras have. The [] is due to typescript's type safety
-        if (camera['speed'] !== undefined) {
-            serializationObject.speed = camera['speed'];
-        }
-
-        if (camera['target'] && camera['target'] instanceof Vector3) {
-            serializationObject.target = camera['target'].asArray();
-        }
-
-        // Target
-        if (camera['rotation'] && camera['rotation'] instanceof Vector3) {
-            serializationObject.rotation = camera['rotation'].asArray();
-        }
-
-        // Locked target
-        if (camera['lockedTarget'] && camera['lockedTarget'].id) {
-            serializationObject.lockedTargetId = camera['lockedTarget'].id;
-        }
-
-        serializationObject.checkCollisions = camera['checkCollisions'] || false;
-        serializationObject.applyGravity = camera['applyGravity'] || false;
-
-        if (camera['ellipsoid']) {
-            serializationObject.ellipsoid = camera['ellipsoid'].asArray();
-        }
-
-        // Animations
-        Animation.AppendSerializedAnimations(camera, serializationObject);
-
-        // Layer mask
-        serializationObject.layerMask = camera.layerMask;
-
-        return serializationObject;
-    };
-
-    var serializeMultiMaterial = (material: MultiMaterial): any => {
-        var serializationObject: any = {};
-
-        serializationObject.name = material.name;
-        serializationObject.id = material.id;
-        serializationObject.tags = Tags.GetTags(material);
-
-        serializationObject.materials = [];
-
-        for (var matIndex = 0; matIndex < material.subMaterials.length; matIndex++) {
-            var subMat = material.subMaterials[matIndex];
-
-            if (subMat) {
-                serializationObject.materials.push(subMat.id);
-            } else {
-                serializationObject.materials.push(null);
-            }
-        }
-
-        return serializationObject;
-    };
-   
-    var serializeSkeleton = (skeleton: Skeleton): any => {
-        var serializationObject: any = {};
-
-        serializationObject.name = skeleton.name;
-        serializationObject.id = skeleton.id;
-
-        serializationObject.bones = [];
-
-        for (var index = 0; index < skeleton.bones.length; index++) {
-            var bone = skeleton.bones[index];
-
-            var serializedBone: any = {
-                parentBoneIndex: bone.getParent() ? skeleton.bones.indexOf(bone.getParent()) : -1,
-                name: bone.name,
-                matrix: bone.getLocalMatrix().toArray()
-            };
-
-            serializationObject.bones.push(serializedBone);
-
-            if (bone.animations && bone.animations.length > 0) {
-                serializedBone.animation = bone.animations[0].serialize();
-            }
-        }
-        return serializationObject;
-    };
-
-    var serializeParticleSystem = (particleSystem: ParticleSystem): any => {
-        var serializationObject: any = {};
-
-        serializationObject.emitterId = particleSystem.emitter.id;
-        serializationObject.capacity = particleSystem.getCapacity();
-
-        if (particleSystem.particleTexture) {
-            serializationObject.textureName = particleSystem.particleTexture.name;
-        }
-
-        serializationObject.minAngularSpeed = particleSystem.minAngularSpeed;
-        serializationObject.maxAngularSpeed = particleSystem.maxAngularSpeed;
-        serializationObject.minSize = particleSystem.minSize;
-        serializationObject.maxSize = particleSystem.maxSize;
-        serializationObject.minLifeTime = particleSystem.minLifeTime;
-        serializationObject.maxLifeTime = particleSystem.maxLifeTime;
-        serializationObject.emitRate = particleSystem.emitRate;
-        serializationObject.minEmitBox = particleSystem.minEmitBox.asArray();
-        serializationObject.maxEmitBox = particleSystem.maxEmitBox.asArray();
-        serializationObject.gravity = particleSystem.gravity.asArray();
-        serializationObject.direction1 = particleSystem.direction1.asArray();
-        serializationObject.direction2 = particleSystem.direction2.asArray();
-        serializationObject.color1 = particleSystem.color1.asArray();
-        serializationObject.color2 = particleSystem.color2.asArray();
-        serializationObject.colorDead = particleSystem.colorDead.asArray();
-        serializationObject.updateSpeed = particleSystem.updateSpeed;
-        serializationObject.targetStopDuration = particleSystem.targetStopDuration;
-        serializationObject.textureMask = particleSystem.textureMask.asArray();
-        serializationObject.blendMode = particleSystem.blendMode;
-
-        return serializationObject;
-    };
-
-    var serializeLensFlareSystem = (lensFlareSystem: LensFlareSystem): any => {
-        var serializationObject: any = {};
-
-        serializationObject.emitterId = lensFlareSystem.getEmitter().id;
-        serializationObject.borderLimit = lensFlareSystem.borderLimit;
-
-        serializationObject.flares = [];
-        for (var index = 0; index < lensFlareSystem.lensFlares.length; index++) {
-            var flare = lensFlareSystem.lensFlares[index];
-
-            serializationObject.flares.push({
-                size: flare.size,
-                position: flare.position,
-                color: flare.color.asArray(),
-                textureName: Tools.GetFilename(flare.texture.name)
-            });
-        }
-
-
-        return serializationObject;
-    };
-
-    var serializeShadowGenerator = (light: Light): any => {
-        var serializationObject: any = {};
-        var shadowGenerator = light.getShadowGenerator();
-
-        serializationObject.lightId = light.id;
-        serializationObject.mapSize = shadowGenerator.getShadowMap().getRenderSize();
-        serializationObject.useVarianceShadowMap = shadowGenerator.useVarianceShadowMap;
-        serializationObject.usePoissonSampling = shadowGenerator.usePoissonSampling;
-
-        serializationObject.renderList = [];
-        for (var meshIndex = 0; meshIndex < shadowGenerator.getShadowMap().renderList.length; meshIndex++) {
-            var mesh = shadowGenerator.getShadowMap().renderList[meshIndex];
-
-            serializationObject.renderList.push(mesh.id);
-        }
-
-        return serializationObject;
-    };
-
+module BABYLON {  
     var serializedGeometries: Geometry[] = [];
     var serializeVertexData: (vertexData: Geometry) => any;
     var serializeTorusKnot: (torusKnot: Geometry.Primitives.TorusKnot) => any;
@@ -568,7 +306,7 @@
                 } else if (mesh.material instanceof MultiMaterial) {
                     serializationObject.multiMaterials = serializationObject.multiMaterials || [];
                     if (!serializationObject.multiMaterials.some(mat => (mat.id === mesh.material.id))) {
-                        serializationObject.multiMaterials.push(serializeMultiMaterial(<MultiMaterial>mesh.material));
+                        serializationObject.multiMaterials.push(mesh.material.serialize());
                     }
 
                 }
@@ -594,7 +332,7 @@
             // Skeletons
             if (mesh.skeleton) {
                 serializationObject.skeletons = serializationObject.skeletons || [];
-                serializationObject.skeletons.push(serializeSkeleton(mesh.skeleton));
+                serializationObject.skeletons.push(mesh.skeleton.serialize());
             }
 
             //serialize the actual mesh
@@ -639,14 +377,14 @@
             var light: Light;
             for (index = 0; index < scene.lights.length; index++) {
                 light = scene.lights[index];
-                serializationObject.lights.push(serializeLight(light));
+                serializationObject.lights.push(light.serialize());
             }
 
             // Cameras
             serializationObject.cameras = [];
             for (index = 0; index < scene.cameras.length; index++) {
                 var camera = scene.cameras[index];
-                serializationObject.cameras.push(serializeCamera(camera));
+                serializationObject.cameras.push(camera.serialize());
             }
 
             if (scene.activeCamera) {
@@ -666,22 +404,18 @@
             serializationObject.multiMaterials = [];
             for (index = 0; index < scene.multiMaterials.length; index++) {
                 var multiMaterial = scene.multiMaterials[index];
-                serializationObject.multiMaterials.push(serializeMultiMaterial(multiMaterial));
+                serializationObject.multiMaterials.push(multiMaterial.serialize());
             }
 
             for (index = 0; index < scene.materials.length; index++) {
                 material = scene.materials[index];
-                if (material instanceof StandardMaterial) {
-                    serializationObject.materials.push(material.serialize());
-                } else if (material instanceof MultiMaterial) {
-                    serializationObject.multiMaterials.push(serializeMultiMaterial(material));
-                }
+                serializationObject.materials.push(material.serialize());
             }
 
             // Skeletons
             serializationObject.skeletons = [];
             for (index = 0; index < scene.skeletons.length; index++) {
-                serializationObject.skeletons.push(serializeSkeleton(scene.skeletons[index]));
+                serializationObject.skeletons.push(scene.skeletons[index].serialize());
             }
 
             // Geometries
@@ -722,13 +456,13 @@
             // Particles Systems
             serializationObject.particleSystems = [];
             for (index = 0; index < scene.particleSystems.length; index++) {
-                serializationObject.particleSystems.push(serializeParticleSystem(scene.particleSystems[index]));
+                serializationObject.particleSystems.push(scene.particleSystems[index].serialize());
             }
 
             // Lens flares
             serializationObject.lensFlareSystems = [];
             for (index = 0; index < scene.lensFlareSystems.length; index++) {
-                serializationObject.lensFlareSystems.push(serializeLensFlareSystem(scene.lensFlareSystems[index]));
+                serializationObject.lensFlareSystems.push(scene.lensFlareSystems[index].serialize());
             }
 
             // Shadows
@@ -737,7 +471,7 @@
                 light = scene.lights[index];
 
                 if (light.getShadowGenerator()) {
-                    serializationObject.shadowGenerators.push(serializeShadowGenerator(light));
+                    serializationObject.shadowGenerators.push(light.getShadowGenerator().serialize());
                 }
             }
 

src/Tools/babylon.tools.js

@@ -19,6 +19,12 @@ var BABYLON;
     var Tools = (function () {
         function Tools() {
         }
+        Tools.GetConstructorName = function (obj) {
+            var str = (obj.prototype ? obj.prototype.constructor : obj.constructor).toString();
+            var cname = str.match(/function\s(\w*)/)[1];
+            var aliases = ["", "anonymous", "Anonymous"];
+            return aliases.indexOf(cname) > -1 ? "Function" : cname;
+        };
         Tools.ToHex = function (i) {
             var str = i.toString(16);
             if (i <= 15) {

src/Tools/babylon.tools.ts

@@ -31,6 +31,14 @@
         public static BaseUrl = "";
         public static CorsBehavior: any = "anonymous";
 
+
+        public static GetConstructorName(obj) {
+            var str = (obj.prototype ? obj.prototype.constructor : obj.constructor).toString();
+            var cname = str.match(/function\s(\w*)/)[1];
+            var aliases = ["", "anonymous", "Anonymous"];
+            return aliases.indexOf(cname) > -1 ? "Function" : cname;
+        }
+
         public static ToHex(i: number): string {
             var str = i.toString(16);