Merge remote-tracking branch 'refs/remotes/BabylonJS/master' into pasring-functions

src/Animations/babylon.animation.js

@@ -403,6 +403,34 @@ var BABYLON;
             }
             return returnValue;
         };
+        Animation.prototype.serialize = function () {
+            var serializationObject = {};
+            serializationObject.name = this.name;
+            serializationObject.property = this.targetProperty;
+            serializationObject.framePerSecond = this.framePerSecond;
+            serializationObject.dataType = this.dataType;
+            serializationObject.loopBehavior = this.loopMode;
+            var dataType = this.dataType;
+            serializationObject.keys = [];
+            var keys = this.getKeys();
+            for (var index = 0; index < keys.length; index++) {
+                var animationKey = keys[index];
+                var key = {};
+                key.frame = animationKey.frame;
+                switch (dataType) {
+                    case Animation.ANIMATIONTYPE_FLOAT:
+                        key.values = [animationKey.value];
+                        break;
+                    case Animation.ANIMATIONTYPE_QUATERNION:
+                    case Animation.ANIMATIONTYPE_MATRIX:
+                    case Animation.ANIMATIONTYPE_VECTOR3:
+                        key.values = animationKey.value.asArray();
+                        break;
+                }
+                serializationObject.keys.push(key);
+            }
+            return serializationObject;
+        };
         Object.defineProperty(Animation, "ANIMATIONTYPE_FLOAT", {
             get: function () {
                 return Animation._ANIMATIONTYPE_FLOAT;
@@ -496,6 +524,15 @@ var BABYLON;
             animation.setKeys(keys);
             return animation;
         };
+        Animation.AppendSerializedAnimations = function (source, destination) {
+            if (source.animations) {
+                destination.animations = [];
+                for (var animationIndex = 0; animationIndex < source.animations.length; animationIndex++) {
+                    var animation = source.animations[animationIndex];
+                    destination.animations.push(animation.serialize());
+                }
+            }
+        };
         // Statics
         Animation._ANIMATIONTYPE_FLOAT = 0;
         Animation._ANIMATIONTYPE_VECTOR3 = 1;

src/Animations/babylon.animation.ts

@@ -466,7 +466,40 @@
             return returnValue;
         }
 
+        public serialize(): any {
+            var serializationObject: any = {};
 
+            serializationObject.name = this.name;
+            serializationObject.property = this.targetProperty;
+            serializationObject.framePerSecond = this.framePerSecond;
+            serializationObject.dataType = this.dataType;
+            serializationObject.loopBehavior = this.loopMode;
+
+            var dataType = this.dataType;
+            serializationObject.keys = [];
+            var keys = this.getKeys();
+            for (var index = 0; index < keys.length; index++) {
+                var animationKey = keys[index];
+
+                var key: any = {};
+                key.frame = animationKey.frame;
+
+                switch (dataType) {
+                    case Animation.ANIMATIONTYPE_FLOAT:
+                        key.values = [animationKey.value];
+                        break;
+                    case Animation.ANIMATIONTYPE_QUATERNION:
+                    case Animation.ANIMATIONTYPE_MATRIX:
+                    case Animation.ANIMATIONTYPE_VECTOR3:
+                        key.values = animationKey.value.asArray();
+                        break;
+                }
+
+                serializationObject.keys.push(key);
+            }
+
+            return serializationObject;
+        }
 
         // Statics
         private static _ANIMATIONTYPE_FLOAT = 0;
@@ -551,6 +584,17 @@
 
             return animation;
         }
+
+        public static AppendSerializedAnimations(source: IAnimatable, destination: any): any {
+            if (source.animations) {
+                destination.animations = [];
+                for (var animationIndex = 0; animationIndex < source.animations.length; animationIndex++) {
+                    var animation = source.animations[animationIndex];
+
+                    destination.animations.push(animation.serialize());
+                }
+            }
+        }
     }
 } 
 

src/Materials/Textures/babylon.baseTexture.js

@@ -114,6 +114,82 @@ var BABYLON;
                 this.onDispose();
             }
         };
+        BaseTexture.prototype.serialize = function () {
+            var serializationObject = {};
+            if (!this.name) {
+                return null;
+            }
+            serializationObject.name = this.name;
+            serializationObject.hasAlpha = this.hasAlpha;
+            serializationObject.level = this.level;
+            serializationObject.coordinatesIndex = this.coordinatesIndex;
+            serializationObject.coordinatesMode = this.coordinatesMode;
+            serializationObject.wrapU = this.wrapU;
+            serializationObject.wrapV = this.wrapV;
+            // Animations
+            BABYLON.Animation.AppendSerializedAnimations(this, serializationObject);
+            return serializationObject;
+        };
+        BaseTexture.ParseCubeTexture = function (parsedTexture, scene, rootUrl) {
+            var texture = null;
+            if ((parsedTexture.name || parsedTexture.extensions) && !parsedTexture.isRenderTarget) {
+                texture = new BABYLON.CubeTexture(rootUrl + parsedTexture.name, scene, parsedTexture.extensions);
+                texture.name = parsedTexture.name;
+                texture.hasAlpha = parsedTexture.hasAlpha;
+                texture.level = parsedTexture.level;
+                texture.coordinatesMode = parsedTexture.coordinatesMode;
+            }
+            return texture;
+        };
+        BaseTexture.ParseTexture = function (parsedTexture, scene, rootUrl) {
+            if (parsedTexture.isCube) {
+                return BaseTexture.ParseCubeTexture(parsedTexture, scene, rootUrl);
+            }
+            if (!parsedTexture.name && !parsedTexture.isRenderTarget) {
+                return null;
+            }
+            var texture;
+            if (parsedTexture.mirrorPlane) {
+                texture = new BABYLON.MirrorTexture(parsedTexture.name, parsedTexture.renderTargetSize, scene);
+                texture._waitingRenderList = parsedTexture.renderList;
+                texture.mirrorPlane = BABYLON.Plane.FromArray(parsedTexture.mirrorPlane);
+            }
+            else if (parsedTexture.isRenderTarget) {
+                texture = new BABYLON.RenderTargetTexture(parsedTexture.name, parsedTexture.renderTargetSize, scene);
+                texture._waitingRenderList = parsedTexture.renderList;
+            }
+            else {
+                if (parsedTexture.base64String) {
+                    texture = BABYLON.Texture.CreateFromBase64String(parsedTexture.base64String, parsedTexture.name, scene);
+                }
+                else {
+                    texture = new BABYLON.Texture(rootUrl + parsedTexture.name, scene);
+                }
+            }
+            texture.name = parsedTexture.name;
+            texture.hasAlpha = parsedTexture.hasAlpha;
+            texture.getAlphaFromRGB = parsedTexture.getAlphaFromRGB;
+            texture.level = parsedTexture.level;
+            texture.coordinatesIndex = parsedTexture.coordinatesIndex;
+            texture.coordinatesMode = parsedTexture.coordinatesMode;
+            texture.uOffset = parsedTexture.uOffset;
+            texture.vOffset = parsedTexture.vOffset;
+            texture.uScale = parsedTexture.uScale;
+            texture.vScale = parsedTexture.vScale;
+            texture.uAng = parsedTexture.uAng;
+            texture.vAng = parsedTexture.vAng;
+            texture.wAng = parsedTexture.wAng;
+            texture.wrapU = parsedTexture.wrapU;
+            texture.wrapV = parsedTexture.wrapV;
+            // Animations
+            if (parsedTexture.animations) {
+                for (var animationIndex = 0; animationIndex < parsedTexture.animations.length; animationIndex++) {
+                    var parsedAnimation = parsedTexture.animations[animationIndex];
+                    texture.animations.push(BABYLON.Animation.ParseAnimation(parsedAnimation));
+                }
+            }
+            return texture;
+        };
         return BaseTexture;
     })();
     BABYLON.BaseTexture = BaseTexture;

src/Materials/Textures/babylon.baseTexture.ts

@@ -144,5 +144,95 @@
                 this.onDispose();
             }
         }
+
+        public serialize(): any {
+            var serializationObject: any = {};
+
+            if (!this.name) {
+                return null;
+            }
+            
+            serializationObject.name = this.name;
+            serializationObject.hasAlpha = this.hasAlpha;
+            serializationObject.level = this.level;
+
+            serializationObject.coordinatesIndex = this.coordinatesIndex;
+            serializationObject.coordinatesMode = this.coordinatesMode;
+            serializationObject.wrapU = this.wrapU;
+            serializationObject.wrapV = this.wrapV;
+
+            // Animations
+            Animation.AppendSerializedAnimations(this, serializationObject);
+
+            return serializationObject;
+        }
+
+        public static ParseCubeTexture(parsedTexture: any, scene: Scene, rootUrl: string): CubeTexture {
+            var texture = null;
+            if ((parsedTexture.name || parsedTexture.extensions) && !parsedTexture.isRenderTarget) {
+                texture = new BABYLON.CubeTexture(rootUrl + parsedTexture.name, scene, parsedTexture.extensions);
+                texture.name = parsedTexture.name;
+                texture.hasAlpha = parsedTexture.hasAlpha;
+                texture.level = parsedTexture.level;
+                texture.coordinatesMode = parsedTexture.coordinatesMode;
+            }
+            return texture;
+        }
+
+        public static ParseTexture(parsedTexture: any, scene: Scene, rootUrl: string): BaseTexture {
+            if (parsedTexture.isCube) {
+                return BaseTexture.ParseCubeTexture(parsedTexture, scene, rootUrl);
+            }
+
+            if (!parsedTexture.name && !parsedTexture.isRenderTarget) {
+                return null;
+            }
+
+            var texture;
+
+            if (parsedTexture.mirrorPlane) {
+                texture = new MirrorTexture(parsedTexture.name, parsedTexture.renderTargetSize, scene);
+                texture._waitingRenderList = parsedTexture.renderList;
+                texture.mirrorPlane = Plane.FromArray(parsedTexture.mirrorPlane);
+            } else if (parsedTexture.isRenderTarget) {
+                texture = new RenderTargetTexture(parsedTexture.name, parsedTexture.renderTargetSize, scene);
+                texture._waitingRenderList = parsedTexture.renderList;
+            } else {
+                if (parsedTexture.base64String) {
+                    texture = Texture.CreateFromBase64String(parsedTexture.base64String, parsedTexture.name, scene);
+                } else {
+                    texture = new Texture(rootUrl + parsedTexture.name, scene);
+                }
+            }
+
+            texture.name = parsedTexture.name;
+            texture.hasAlpha = parsedTexture.hasAlpha;
+            texture.getAlphaFromRGB = parsedTexture.getAlphaFromRGB;
+            texture.level = parsedTexture.level;
+
+            texture.coordinatesIndex = parsedTexture.coordinatesIndex;
+            texture.coordinatesMode = parsedTexture.coordinatesMode;
+            texture.uOffset = parsedTexture.uOffset;
+            texture.vOffset = parsedTexture.vOffset;
+            texture.uScale = parsedTexture.uScale;
+            texture.vScale = parsedTexture.vScale;
+            texture.uAng = parsedTexture.uAng;
+            texture.vAng = parsedTexture.vAng;
+            texture.wAng = parsedTexture.wAng;
+
+            texture.wrapU = parsedTexture.wrapU;
+            texture.wrapV = parsedTexture.wrapV;
+
+            // Animations
+            if (parsedTexture.animations) {
+                for (var animationIndex = 0; animationIndex < parsedTexture.animations.length; animationIndex++) {
+                    var parsedAnimation = parsedTexture.animations[animationIndex];
+
+                    texture.animations.push(Animation.ParseAnimation(parsedAnimation));
+                }
+            }
+
+            return texture;
+        }
     }
 } 

src/Materials/Textures/babylon.cubeTexture.js

@@ -57,16 +57,17 @@ var BABYLON;
         CubeTexture.prototype.getReflectionTextureMatrix = function () {
             return this._textureMatrix;
         };
-        CubeTexture.ParseCubeTexture = function (parsedTexture, scene, rootUrl) {
-            var texture = null;
-            if ((parsedTexture.name || parsedTexture.extensions) && !parsedTexture.isRenderTarget) {
-                texture = new BABYLON.CubeTexture(rootUrl + parsedTexture.name, scene, parsedTexture.extensions);
-                texture.name = parsedTexture.name;
-                texture.hasAlpha = parsedTexture.hasAlpha;
-                texture.level = parsedTexture.level;
-                texture.coordinatesMode = parsedTexture.coordinatesMode;
+        CubeTexture.prototype.serialize = function () {
+            if (!this.name) {
+                return null;
             }
-            return texture;
+            var serializationObject = {};
+            serializationObject.name = this.name;
+            serializationObject.hasAlpha = this.hasAlpha;
+            serializationObject.isCube = true;
+            serializationObject.level = this.level;
+            serializationObject.coordinatesMode = this.coordinatesMode;
+            return serializationObject;
         };
         return CubeTexture;
     })(BABYLON.BaseTexture);

src/Materials/Textures/babylon.cubeTexture.ts

@@ -82,5 +82,20 @@
             }
             return texture;
         }
+
+        public serialize(): any {
+            if (!this.name) {
+                return null;
+            }
+
+            var serializationObject: any = {};
+            serializationObject.name = this.name;
+            serializationObject.hasAlpha = this.hasAlpha;
+            serializationObject.isCube = true;
+            serializationObject.level = this.level;
+            serializationObject.coordinatesMode = this.coordinatesMode;
+
+            return serializationObject;
+        }
     }
 } 

src/Materials/Textures/babylon.mirrorTexture.js

@@ -40,6 +40,14 @@ var BABYLON;
             newTexture.renderList = this.renderList.slice(0);
             return newTexture;
         };
+        MirrorTexture.prototype.serialize = function () {
+            if (!this.name) {
+                return null;
+            }
+            var serializationObject = _super.prototype.serialize.call(this);
+            serializationObject.mirrorPlane = this.mirrorPlane.asArray();
+            return serializationObject;
+        };
         return MirrorTexture;
     })(BABYLON.RenderTargetTexture);
     BABYLON.MirrorTexture = MirrorTexture;

src/Materials/Textures/babylon.mirrorTexture.ts

@@ -47,5 +47,17 @@
 
             return newTexture;
         }
+
+        public serialize(): any {
+            if (!this.name) {
+                return null;
+            }
+
+            var serializationObject = super.serialize();
+
+            serializationObject.mirrorPlane = this.mirrorPlane.asArray();
+
+            return serializationObject;
+        }
     }
 } 

src/Materials/Textures/babylon.renderTargetTexture.js

@@ -226,6 +226,18 @@ var BABYLON;
             newTexture.renderList = this.renderList.slice(0);
             return newTexture;
         };
+        RenderTargetTexture.prototype.serialize = function () {
+            if (!this.name) {
+                return null;
+            }
+            var serializationObject = _super.prototype.serialize.call(this);
+            serializationObject.renderTargetSize = this.getRenderSize();
+            serializationObject.renderList = [];
+            for (var index = 0; index < this.renderList.length; index++) {
+                serializationObject.renderList.push(this.renderList[index].id);
+            }
+            return serializationObject;
+        };
         RenderTargetTexture._REFRESHRATE_RENDER_ONCE = 0;
         RenderTargetTexture._REFRESHRATE_RENDER_ONEVERYFRAME = 1;
         RenderTargetTexture._REFRESHRATE_RENDER_ONEVERYTWOFRAMES = 2;

src/Materials/Textures/babylon.renderTargetTexture.ts

@@ -258,5 +258,22 @@
 
             return newTexture;
         }
+
+        public serialize(): any {
+            if (!this.name) {
+                return null;
+            }
+
+            var serializationObject = super.serialize();
+
+            serializationObject.renderTargetSize = this.getRenderSize();
+            serializationObject.renderList = [];
+
+            for (var index = 0; index < this.renderList.length; index++) {
+                serializationObject.renderList.push(this.renderList[index].id);
+            }
+
+            return serializationObject;
+        }
     }
 } 

src/Materials/Textures/babylon.texture.js

@@ -180,6 +180,20 @@ var BABYLON;
             newTexture.wAng = this.wAng;
             return newTexture;
         };
+        Texture.prototype.serialize = function () {
+            if (!this.name) {
+                return null;
+            }
+            var serializationObject = _super.prototype.serialize.call(this);
+            serializationObject.uOffset = this.uOffset;
+            serializationObject.vOffset = this.vOffset;
+            serializationObject.uScale = this.uScale;
+            serializationObject.vScale = this.vScale;
+            serializationObject.uAng = this.uAng;
+            serializationObject.vAng = this.vAng;
+            serializationObject.wAng = this.wAng;
+            return serializationObject;
+        };
         // Statics
         Texture.CreateFromBase64String = function (data, name, scene, noMipmap, invertY, samplingMode, onLoad, onError) {
             if (samplingMode === void 0) { samplingMode = Texture.TRILINEAR_SAMPLINGMODE; }

src/Materials/Textures/babylon.texture.ts

@@ -237,6 +237,24 @@
             return newTexture;
         }
 
+        public serialize(): any {
+            if (!this.name) {
+                return null;
+            }
+
+            var serializationObject = super.serialize();
+
+            serializationObject.uOffset = this.uOffset;
+            serializationObject.vOffset = this.vOffset;
+            serializationObject.uScale = this.uScale;
+            serializationObject.vScale = this.vScale;
+            serializationObject.uAng = this.uAng;
+            serializationObject.vAng = this.vAng;
+            serializationObject.wAng = this.wAng;
+
+            return serializationObject;
+        }
+
         // Statics
         public static CreateFromBase64String(data: string, name: string, scene: Scene, noMipmap?: boolean, invertY?: boolean, samplingMode: number = Texture.TRILINEAR_SAMPLINGMODE, onLoad: () => void = null, onError: () => void = null): Texture {
             return new Texture("data:" + name, scene, noMipmap, invertY, samplingMode, onLoad, onError, data);

src/Materials/babylon.material.js

@@ -232,12 +232,14 @@ var BABYLON;
             other.pointSize = this.pointSize;
             other.pointsCloud = this.pointsCloud;
         };
-        Material.ParseMaterial = function (parsedMaterial, scene, rootUrl) {
-            if (!parsedMaterial.customType) {
-                return BABYLON.StandardMaterial.Parse(parsedMaterial, scene, rootUrl);
-            }
-            //TODO this is where custom materials are inspected and parsed.
-            return null;
+        Material.prototype.serialize = function () {
+            var serializationObject = {};
+            serializationObject.name = this.name;
+            serializationObject.alpha = this.alpha;
+            serializationObject.id = this.id;
+            serializationObject.tags = BABYLON.Tags.GetTags(this);
+            serializationObject.backFaceCulling = this.backFaceCulling;
+            return serializationObject;
         };
         Material._TriangleFillMode = 0;
         Material._WireFrameFillMode = 1;

src/Materials/babylon.material.ts

@@ -267,6 +267,19 @@
             other.pointsCloud = this.pointsCloud;
         }
 
+        public serialize(): any {
+            var serializationObject: any = {};
+
+            serializationObject.name = this.name;
+            serializationObject.alpha = this.alpha;
+
+            serializationObject.id = this.id;
+            serializationObject.tags = Tags.GetTags(this);
+            serializationObject.backFaceCulling = this.backFaceCulling;
+
+            return serializationObject;
+        }
+
         public static ParseMaterial(parsedMaterial: any, scene: Scene, rootUrl: string) {
             if (!parsedMaterial.customType) {
                 return StandardMaterial.Parse(parsedMaterial, scene, rootUrl);

src/Materials/babylon.standardMaterial.js

@@ -19,6 +19,15 @@ var BABYLON;
             BABYLON.Tools.DeepCopy(this, newFresnelParameters);
             return new FresnelParameters;
         };
+        FresnelParameters.prototype.serialize = function () {
+            var serializationObject = {};
+            serializationObject.isEnabled = this.isEnabled;
+            serializationObject.leftColor = this.leftColor;
+            serializationObject.rightColor = this.rightColor;
+            serializationObject.bias = this.bias;
+            serializationObject.power = this.power;
+            return serializationObject;
+        };
         return FresnelParameters;
     })();
     BABYLON.FresnelParameters = FresnelParameters;
@@ -868,6 +877,54 @@ var BABYLON;
             }
             return newStandardMaterial;
         };
+        StandardMaterial.prototype.serialize = function () {
+            var serializationObject = _super.prototype.serialize.call(this);
+            serializationObject.ambient = this.ambientColor.asArray();
+            serializationObject.diffuse = this.diffuseColor.asArray();
+            serializationObject.specular = this.specularColor.asArray();
+            serializationObject.specularPower = this.specularPower;
+            serializationObject.emissive = this.emissiveColor.asArray();
+            serializationObject.useReflectionFresnelFromSpecular = serializationObject.useReflectionFresnelFromSpecular;
+            serializationObject.useEmissiveAsIllumination = serializationObject.useEmissiveAsIllumination;
+            if (this.diffuseTexture) {
+                serializationObject.diffuseTexture = this.diffuseTexture.serialize();
+            }
+            if (this.diffuseFresnelParameters) {
+                serializationObject.diffuseFresnelParameters = this.diffuseFresnelParameters.serialize();
+            }
+            if (this.ambientTexture) {
+                serializationObject.ambientTexture = this.ambientTexture.serialize();
+            }
+            if (this.opacityTexture) {
+                serializationObject.opacityTexture = this.opacityTexture.serialize();
+            }
+            if (this.opacityFresnelParameters) {
+                serializationObject.opacityFresnelParameters = this.diffuseFresnelParameters.serialize();
+            }
+            if (this.reflectionTexture) {
+                serializationObject.reflectionTexture = this.reflectionTexture.serialize();
+            }
+            if (this.reflectionFresnelParameters) {
+                serializationObject.reflectionFresnelParameters = this.reflectionFresnelParameters.serialize();
+            }
+            if (this.emissiveTexture) {
+                serializationObject.emissiveTexture = this.emissiveTexture.serialize();
+            }
+            if (this.lightmapTexture) {
+                serializationObject.lightmapTexture = this.lightmapTexture.serialize();
+                serializationObject.useLightmapAsShadowmap = this.useLightmapAsShadowmap;
+            }
+            if (this.emissiveFresnelParameters) {
+                serializationObject.emissiveFresnelParameters = this.emissiveFresnelParameters.serialize();
+            }
+            if (this.specularTexture) {
+                serializationObject.specularTexture = this.specularTexture.serialize();
+            }
+            if (this.bumpTexture) {
+                serializationObject.bumpTexture = this.bumpTexture.serialize();
+            }
+            return serializationObject;
+        };
         StandardMaterial.ParseFresnelParameters = function (parsedFresnelParameters) {
             var fresnelParameters = new FresnelParameters();
             fresnelParameters.isEnabled = parsedFresnelParameters.isEnabled;

src/Materials/babylon.standardMaterial.ts

@@ -15,6 +15,18 @@
 
             return new FresnelParameters;
         }
+
+        public serialize(): any {
+            var serializationObject: any = {};
+
+            serializationObject.isEnabled = this.isEnabled;
+            serializationObject.leftColor = this.leftColor;
+            serializationObject.rightColor = this.rightColor;
+            serializationObject.bias = this.bias;
+            serializationObject.power = this.power;
+
+            return serializationObject;
+        }
     }
 
     class StandardMaterialDefines extends MaterialDefines {
@@ -289,7 +301,7 @@
 
             return needNormals;
         }
-        
+
         private static _scaledDiffuse = new Color3();
         private static _scaledSpecular = new Color3();
         public static BindLights(scene: Scene, mesh: AbstractMesh, effect: Effect, defines: MaterialDefines) {
@@ -675,8 +687,8 @@
                     fallbacks.addFallback(4, "FRESNEL");
                 }
 
-                if (this._defines.NUM_BONE_INFLUENCERS > 0){
-                    fallbacks.addCPUSkinningFallback(0, mesh);    
+                if (this._defines.NUM_BONE_INFLUENCERS > 0) {
+                    fallbacks.addCPUSkinningFallback(0, mesh);
                 }
 
                 //Attributes
@@ -1045,6 +1057,69 @@
             return newStandardMaterial;
         }
 
+        public serialize(): any {
+            var serializationObject = super.serialize();
+
+            serializationObject.ambient = this.ambientColor.asArray();
+            serializationObject.diffuse = this.diffuseColor.asArray();
+            serializationObject.specular = this.specularColor.asArray();
+            serializationObject.specularPower = this.specularPower;
+            serializationObject.emissive = this.emissiveColor.asArray();
+            serializationObject.useReflectionFresnelFromSpecular = serializationObject.useReflectionFresnelFromSpecular;
+            serializationObject.useEmissiveAsIllumination = serializationObject.useEmissiveAsIllumination;
+
+            if (this.diffuseTexture) {
+                serializationObject.diffuseTexture = this.diffuseTexture.serialize();
+            }
+
+            if (this.diffuseFresnelParameters) {
+                serializationObject.diffuseFresnelParameters = this.diffuseFresnelParameters.serialize();
+            }
+
+            if (this.ambientTexture) {
+                serializationObject.ambientTexture = this.ambientTexture.serialize();
+            }
+
+            if (this.opacityTexture) {
+                serializationObject.opacityTexture = this.opacityTexture.serialize();
+            }
+
+            if (this.opacityFresnelParameters) {
+                serializationObject.opacityFresnelParameters = this.diffuseFresnelParameters.serialize();
+            }
+
+            if (this.reflectionTexture) {
+                serializationObject.reflectionTexture = this.reflectionTexture.serialize();
+            }
+
+            if (this.reflectionFresnelParameters) {
+                serializationObject.reflectionFresnelParameters = this.reflectionFresnelParameters.serialize();
+            }
+
+            if (this.emissiveTexture) {
+                serializationObject.emissiveTexture = this.emissiveTexture.serialize();
+            }
+
+            if (this.lightmapTexture) {
+                serializationObject.lightmapTexture = this.lightmapTexture.serialize();
+                serializationObject.useLightmapAsShadowmap = this.useLightmapAsShadowmap;
+            }
+
+            if (this.emissiveFresnelParameters) {
+                serializationObject.emissiveFresnelParameters = this.emissiveFresnelParameters.serialize();
+            }
+
+            if (this.specularTexture) {
+                serializationObject.specularTexture = this.specularTexture.serialize();
+            }
+
+            if (this.bumpTexture) {
+                serializationObject.bumpTexture = this.bumpTexture.serialize();
+            }
+
+            return serializationObject;
+        }
+
         // Statics
         // Flags used to enable or disable a type of texture for all Standard Materials
         public static DiffuseTextureEnabled = true;
@@ -1097,7 +1172,7 @@
             }
 
             if (source.diffuseFresnelParameters) {
-                material.diffuseFresnelParameters =  StandardMaterial.ParseFresnelParameters(source.diffuseFresnelParameters);
+                material.diffuseFresnelParameters = StandardMaterial.ParseFresnelParameters(source.diffuseFresnelParameters);
             }
 
             if (source.ambientTexture) {

src/Tools/babylon.sceneSerializer.js

@@ -37,25 +37,6 @@ var BABYLON;
         serializationObject.specular = light.specular.asArray();
         return serializationObject;
     };
-    var serializeFresnelParameter = function (fresnelParameter) {
-        var serializationObject = {};
-        serializationObject.isEnabled = fresnelParameter.isEnabled;
-        serializationObject.leftColor = fresnelParameter.leftColor;
-        serializationObject.rightColor = fresnelParameter.rightColor;
-        serializationObject.bias = fresnelParameter.bias;
-        serializationObject.power = fresnelParameter.power;
-        return serializationObject;
-    };
-    var serializeAnimation;
-    var appendAnimations = function (source, destination) {
-        if (source.animations) {
-            destination.animations = [];
-            for (var animationIndex = 0; animationIndex < source.animations.length; animationIndex++) {
-                var animation = source.animations[animationIndex];
-                destination.animations.push(serializeAnimation(animation));
-            }
-        }
-    };
     var serializeCamera = function (camera) {
         var serializationObject = {};
         serializationObject.name = camera.name;
@@ -147,39 +128,11 @@ var BABYLON;
             serializationObject.ellipsoid = camera['ellipsoid'].asArray();
         }
         // Animations
-        appendAnimations(camera, serializationObject);
+        BABYLON.Animation.AppendSerializedAnimations(camera, serializationObject);
         // Layer mask
         serializationObject.layerMask = camera.layerMask;
         return serializationObject;
     };
-    serializeAnimation = function (animation) {
-        var serializationObject = {};
-        serializationObject.name = animation.name;
-        serializationObject.property = animation.targetProperty;
-        serializationObject.framePerSecond = animation.framePerSecond;
-        serializationObject.dataType = animation.dataType;
-        serializationObject.loopBehavior = animation.loopMode;
-        var dataType = animation.dataType;
-        serializationObject.keys = [];
-        var keys = animation.getKeys();
-        for (var index = 0; index < keys.length; index++) {
-            var animationKey = keys[index];
-            var key = {};
-            key.frame = animationKey.frame;
-            switch (dataType) {
-                case BABYLON.Animation.ANIMATIONTYPE_FLOAT:
-                    key.values = [animationKey.value];
-                    break;
-                case BABYLON.Animation.ANIMATIONTYPE_QUATERNION:
-                case BABYLON.Animation.ANIMATIONTYPE_MATRIX:
-                case BABYLON.Animation.ANIMATIONTYPE_VECTOR3:
-                    key.values = animationKey.value.asArray();
-                    break;
-            }
-            serializationObject.keys.push(key);
-        }
-        return serializationObject;
-    };
     var serializeMultiMaterial = function (material) {
         var serializationObject = {};
         serializationObject.name = material.name;
@@ -197,110 +150,6 @@ var BABYLON;
         }
         return serializationObject;
     };
-    var serializeTexture;
-    var serializeMaterial = function (material) {
-        var serializationObject = {};
-        serializationObject.name = material.name;
-        serializationObject.ambient = material.ambientColor.asArray();
-        serializationObject.diffuse = material.diffuseColor.asArray();
-        serializationObject.specular = material.specularColor.asArray();
-        serializationObject.specularPower = material.specularPower;
-        serializationObject.emissive = material.emissiveColor.asArray();
-        serializationObject.useReflectionFresnelFromSpecular = serializationObject.useReflectionFresnelFromSpecular;
-        serializationObject.useEmissiveAsIllumination = serializationObject.useEmissiveAsIllumination;
-        serializationObject.alpha = material.alpha;
-        serializationObject.id = material.id;
-        serializationObject.tags = BABYLON.Tags.GetTags(material);
-        serializationObject.backFaceCulling = material.backFaceCulling;
-        if (material.diffuseTexture) {
-            serializationObject.diffuseTexture = serializeTexture(material.diffuseTexture);
-        }
-        if (material.diffuseFresnelParameters) {
-            serializationObject.diffuseFresnelParameters = serializeFresnelParameter(material.diffuseFresnelParameters);
-        }
-        if (material.ambientTexture) {
-            serializationObject.ambientTexture = serializeTexture(material.ambientTexture);
-        }
-        if (material.opacityTexture) {
-            serializationObject.opacityTexture = serializeTexture(material.opacityTexture);
-        }
-        if (material.opacityFresnelParameters) {
-            serializationObject.opacityFresnelParameters = serializeFresnelParameter(material.opacityFresnelParameters);
-        }
-        if (material.reflectionTexture) {
-            serializationObject.reflectionTexture = serializeTexture(material.reflectionTexture);
-        }
-        if (material.reflectionFresnelParameters) {
-            serializationObject.reflectionFresnelParameters = serializeFresnelParameter(material.reflectionFresnelParameters);
-        }
-        if (material.emissiveTexture) {
-            serializationObject.emissiveTexture = serializeTexture(material.emissiveTexture);
-        }
-        if (material.lightmapTexture) {
-            serializationObject.lightmapTexture = serializeTexture(material.lightmapTexture);
-            serializationObject.useLightmapAsShadowmap = material.useLightmapAsShadowmap;
-        }
-        if (material.emissiveFresnelParameters) {
-            serializationObject.emissiveFresnelParameters = serializeFresnelParameter(material.emissiveFresnelParameters);
-        }
-        if (material.specularTexture) {
-            serializationObject.specularTexture = serializeTexture(material.specularTexture);
-        }
-        if (material.bumpTexture) {
-            serializationObject.bumpTexture = serializeTexture(material.bumpTexture);
-        }
-        return serializationObject;
-    };
-    serializeTexture = function (texture) {
-        var serializationObject = {};
-        if (!texture.name) {
-            return null;
-        }
-        if (texture instanceof BABYLON.CubeTexture) {
-            serializationObject.name = texture.name;
-            serializationObject.hasAlpha = texture.hasAlpha;
-            serializationObject.isCube = true;
-            serializationObject.level = texture.level;
-            serializationObject.coordinatesMode = texture.coordinatesMode;
-            return serializationObject;
-        }
-        var index;
-        if (texture instanceof BABYLON.MirrorTexture) {
-            var mirrorTexture = texture;
-            serializationObject.renderTargetSize = mirrorTexture.getRenderSize();
-            serializationObject.renderList = [];
-            for (index = 0; index < mirrorTexture.renderList.length; index++) {
-                serializationObject.renderList.push(mirrorTexture.renderList[index].id);
-            }
-            serializationObject.mirrorPlane = mirrorTexture.mirrorPlane.asArray();
-        }
-        else if (texture instanceof BABYLON.RenderTargetTexture) {
-            var renderTargetTexture = texture;
-            serializationObject.renderTargetSize = renderTargetTexture.getRenderSize();
-            serializationObject.renderList = [];
-            for (index = 0; index < renderTargetTexture.renderList.length; index++) {
-                serializationObject.renderList.push(renderTargetTexture.renderList[index].id);
-            }
-        }
-        var regularTexture = texture;
-        serializationObject.name = texture.name;
-        serializationObject.hasAlpha = texture.hasAlpha;
-        serializationObject.level = texture.level;
-        serializationObject.coordinatesIndex = texture.coordinatesIndex;
-        serializationObject.coordinatesMode = texture.coordinatesMode;
-        serializationObject.uOffset = regularTexture.uOffset;
-        serializationObject.vOffset = regularTexture.vOffset;
-        serializationObject.uScale = regularTexture.uScale;
-        serializationObject.vScale = regularTexture.vScale;
-        serializationObject.uAng = regularTexture.uAng;
-        serializationObject.vAng = regularTexture.vAng;
-        serializationObject.wAng = regularTexture.wAng;
-        serializationObject.wrapU = texture.wrapU;
-        serializationObject.wrapV = texture.wrapV;
-        // Animations
-        appendAnimations(texture, serializationObject);
-        return serializationObject;
-    };
     var serializeSkeleton = function (skeleton) {
         var serializationObject = {};
         serializationObject.name = skeleton.name;
@@ -315,7 +164,7 @@ var BABYLON;
             };
             serializationObject.bones.push(serializedBone);
             if (bone.animations && bone.animations.length > 0) {
-                serializedBone.animation = serializeAnimation(bone.animations[0]);
+                serializedBone.animation = bone.animations[0].serialize();
             }
         }
         return serializationObject;
@@ -608,10 +457,10 @@ var BABYLON;
             };
             serializationObject.instances.push(serializationInstance);
             // Animations
-            appendAnimations(instance, serializationInstance);
+            BABYLON.Animation.AppendSerializedAnimations(instance, serializationInstance);
         }
         // Animations
-        appendAnimations(mesh, serializationObject);
+        BABYLON.Animation.AppendSerializedAnimations(mesh, serializationObject);
         // Layer mask
         serializationObject.layerMask = mesh.layerMask;
         return serializationObject;
@@ -624,7 +473,7 @@ var BABYLON;
                 if (mesh.material instanceof BABYLON.StandardMaterial) {
                     serializationObject.materials = serializationObject.materials || [];
                     if (!serializationObject.materials.some(function (mat) { return (mat.id === mesh.material.id); })) {
-                        serializationObject.materials.push(serializeMaterial(mesh.material));
+                        serializationObject.materials.push(mesh.material.serialize());
                     }
                 }
                 else if (mesh.material instanceof BABYLON.MultiMaterial) {
@@ -710,7 +559,7 @@ var BABYLON;
             var material;
             for (index = 0; index < scene.materials.length; index++) {
                 material = scene.materials[index];
-                serializationObject.materials.push(serializeMaterial(material));
+                serializationObject.materials.push(material.serialize());
             }
             // MultiMaterials
             serializationObject.multiMaterials = [];
@@ -721,7 +570,7 @@ var BABYLON;
             for (index = 0; index < scene.materials.length; index++) {
                 material = scene.materials[index];
                 if (material instanceof BABYLON.StandardMaterial) {
-                    serializationObject.materials.push(serializeMaterial(material));
+                    serializationObject.materials.push(material.serialize());
                 }
                 else if (material instanceof BABYLON.MultiMaterial) {
                     serializationObject.multiMaterials.push(serializeMultiMaterial(material));

src/Tools/babylon.sceneSerializer.ts

@@ -40,29 +40,6 @@
         return serializationObject;
     };
 
-    var serializeFresnelParameter = (fresnelParameter: FresnelParameters): any => {
-        var serializationObject: any = {};
-
-        serializationObject.isEnabled = fresnelParameter.isEnabled;
-        serializationObject.leftColor = fresnelParameter.leftColor;
-        serializationObject.rightColor = fresnelParameter.rightColor;
-        serializationObject.bias = fresnelParameter.bias;
-        serializationObject.power = fresnelParameter.power;
-
-        return serializationObject;
-    }
-    var serializeAnimation: (animation: Animation) => any;
-    var appendAnimations = (source: IAnimatable, destination: any): any => {
-        if (source.animations) {
-            destination.animations = [];
-            for (var animationIndex = 0; animationIndex < source.animations.length; animationIndex++) {
-                var animation = source.animations[animationIndex];
-
-                destination.animations.push(serializeAnimation(animation));
-            }
-        }
-    };
-
     var serializeCamera = (camera: Camera): any => {
         var serializationObject: any = {};
         serializationObject.name = camera.name;
@@ -154,47 +131,14 @@
         }
 
         // Animations
-        appendAnimations(camera, serializationObject);
+        Animation.AppendSerializedAnimations(camera, serializationObject);
 
         // Layer mask
         serializationObject.layerMask = camera.layerMask;
 
         return serializationObject;
     };
-    serializeAnimation = (animation: Animation): any => {
-        var serializationObject: any = {};
 
-        serializationObject.name = animation.name;
-        serializationObject.property = animation.targetProperty;
-        serializationObject.framePerSecond = animation.framePerSecond;
-        serializationObject.dataType = animation.dataType;
-        serializationObject.loopBehavior = animation.loopMode;
-
-        var dataType = animation.dataType;
-        serializationObject.keys = [];
-        var keys = animation.getKeys();
-        for (var index = 0; index < keys.length; index++) {
-            var animationKey = keys[index];
-
-            var key: any = {};
-            key.frame = animationKey.frame;
-
-            switch (dataType) {
-                case Animation.ANIMATIONTYPE_FLOAT:
-                    key.values = [animationKey.value];
-                    break;
-                case Animation.ANIMATIONTYPE_QUATERNION:
-                case Animation.ANIMATIONTYPE_MATRIX:
-                case Animation.ANIMATIONTYPE_VECTOR3:
-                    key.values = animationKey.value.asArray();
-                    break;
-            }
-
-            serializationObject.keys.push(key);
-        }
-
-        return serializationObject;
-    };
     var serializeMultiMaterial = (material: MultiMaterial): any => {
         var serializationObject: any = {};
 
@@ -216,138 +160,7 @@
 
         return serializationObject;
     };
-    var serializeTexture: (texture: BaseTexture) => any;
-    var serializeMaterial = (material: StandardMaterial): any => {
-        var serializationObject: any = {};
-
-        serializationObject.name = material.name;
-
-        serializationObject.ambient = material.ambientColor.asArray();
-        serializationObject.diffuse = material.diffuseColor.asArray();
-        serializationObject.specular = material.specularColor.asArray();
-        serializationObject.specularPower = material.specularPower;
-        serializationObject.emissive = material.emissiveColor.asArray();
-        serializationObject.useReflectionFresnelFromSpecular = serializationObject.useReflectionFresnelFromSpecular;
-        serializationObject.useEmissiveAsIllumination = serializationObject.useEmissiveAsIllumination;
-
-        serializationObject.alpha = material.alpha;
-
-        serializationObject.id = material.id;
-        serializationObject.tags = Tags.GetTags(material);
-        serializationObject.backFaceCulling = material.backFaceCulling;
-
-        if (material.diffuseTexture) {
-            serializationObject.diffuseTexture = serializeTexture(material.diffuseTexture);
-        }
-
-        if (material.diffuseFresnelParameters) {
-            serializationObject.diffuseFresnelParameters = serializeFresnelParameter(material.diffuseFresnelParameters);
-        }
-
-        if (material.ambientTexture) {
-            serializationObject.ambientTexture = serializeTexture(material.ambientTexture);
-        }
-
-        if (material.opacityTexture) {
-            serializationObject.opacityTexture = serializeTexture(material.opacityTexture);
-        }
-
-        if (material.opacityFresnelParameters) {
-            serializationObject.opacityFresnelParameters = serializeFresnelParameter(material.opacityFresnelParameters);
-        }
-
-        if (material.reflectionTexture) {
-            serializationObject.reflectionTexture = serializeTexture(material.reflectionTexture);
-        }
-
-        if (material.reflectionFresnelParameters) {
-            serializationObject.reflectionFresnelParameters = serializeFresnelParameter(material.reflectionFresnelParameters);
-        }
-
-        if (material.emissiveTexture) {
-            serializationObject.emissiveTexture = serializeTexture(material.emissiveTexture);
-        }
-
-        if (material.lightmapTexture) {
-            serializationObject.lightmapTexture = serializeTexture(material.lightmapTexture);
-            serializationObject.useLightmapAsShadowmap = material.useLightmapAsShadowmap;
-        }
-
-        if (material.emissiveFresnelParameters) {
-            serializationObject.emissiveFresnelParameters = serializeFresnelParameter(material.emissiveFresnelParameters);
-        }
-
-        if (material.specularTexture) {
-            serializationObject.specularTexture = serializeTexture(material.specularTexture);
-        }
-
-        if (material.bumpTexture) {
-            serializationObject.bumpTexture = serializeTexture(material.bumpTexture);
-        }
-
-        return serializationObject;
-    };
-    serializeTexture = (texture: BaseTexture): any => {
-        var serializationObject: any = {};
-
-        if (!texture.name) {
-            return null;
-        }
-
-        if (texture instanceof CubeTexture) {
-            serializationObject.name = texture.name;
-            serializationObject.hasAlpha = texture.hasAlpha;
-            serializationObject.isCube = true;
-            serializationObject.level = texture.level;
-            serializationObject.coordinatesMode = texture.coordinatesMode;
-
-            return serializationObject;
-        }
-        var index: number;
-        if (texture instanceof MirrorTexture) {
-            var mirrorTexture = texture;
-            serializationObject.renderTargetSize = mirrorTexture.getRenderSize();
-            serializationObject.renderList = [];
-
-            for (index = 0; index < mirrorTexture.renderList.length; index++) {
-                serializationObject.renderList.push(mirrorTexture.renderList[index].id);
-            }
-
-            serializationObject.mirrorPlane = mirrorTexture.mirrorPlane.asArray();
-        } else if (texture instanceof RenderTargetTexture) {
-            var renderTargetTexture = texture;
-            serializationObject.renderTargetSize = renderTargetTexture.getRenderSize();
-            serializationObject.renderList = [];
-
-            for (index = 0; index < renderTargetTexture.renderList.length; index++) {
-                serializationObject.renderList.push(renderTargetTexture.renderList[index].id);
-            }
-        }
-
-        var regularTexture = <Texture>texture;
-
-        serializationObject.name = texture.name;
-        serializationObject.hasAlpha = texture.hasAlpha;
-        serializationObject.level = texture.level;
-
-        serializationObject.coordinatesIndex = texture.coordinatesIndex;
-        serializationObject.coordinatesMode = texture.coordinatesMode;
-        serializationObject.uOffset = regularTexture.uOffset;
-        serializationObject.vOffset = regularTexture.vOffset;
-        serializationObject.uScale = regularTexture.uScale;
-        serializationObject.vScale = regularTexture.vScale;
-        serializationObject.uAng = regularTexture.uAng;
-        serializationObject.vAng = regularTexture.vAng;
-        serializationObject.wAng = regularTexture.wAng;
-
-        serializationObject.wrapU = texture.wrapU;
-        serializationObject.wrapV = texture.wrapV;
-
-        // Animations
-        appendAnimations(texture, serializationObject);
-
-        return serializationObject;
-    };
+   
     var serializeSkeleton = (skeleton: Skeleton): any => {
         var serializationObject: any = {};
 
@@ -368,7 +181,7 @@
             serializationObject.bones.push(serializedBone);
 
             if (bone.animations && bone.animations.length > 0) {
-                serializedBone.animation = serializeAnimation(bone.animations[0]);
+                serializedBone.animation = bone.animations[0].serialize();
             }
         }
         return serializationObject;
@@ -730,11 +543,11 @@
             serializationObject.instances.push(serializationInstance);
 
             // Animations
-            appendAnimations(instance, serializationInstance);
+            Animation.AppendSerializedAnimations(instance, serializationInstance);
         }
 
         // Animations
-        appendAnimations(mesh, serializationObject);
+        Animation.AppendSerializedAnimations(mesh, serializationObject);
 
         // Layer mask
         serializationObject.layerMask = mesh.layerMask;
@@ -750,7 +563,7 @@
                 if (mesh.material instanceof StandardMaterial) {
                     serializationObject.materials = serializationObject.materials || [];
                     if (!serializationObject.materials.some(mat => (mat.id === mesh.material.id))) {
-                        serializationObject.materials.push(serializeMaterial(<StandardMaterial>mesh.material));
+                        serializationObject.materials.push(mesh.material.serialize());
                     }
                 } else if (mesh.material instanceof MultiMaterial) {
                     serializationObject.multiMaterials = serializationObject.multiMaterials || [];
@@ -846,7 +659,7 @@
             var material: Material;
             for (index = 0; index < scene.materials.length; index++) {
                 material = scene.materials[index];
-                serializationObject.materials.push(serializeMaterial(<StandardMaterial>material));
+                serializationObject.materials.push(material.serialize());
             }
 
             // MultiMaterials
@@ -859,7 +672,7 @@
             for (index = 0; index < scene.materials.length; index++) {
                 material = scene.materials[index];
                 if (material instanceof StandardMaterial) {
-                    serializationObject.materials.push(serializeMaterial(material));
+                    serializationObject.materials.push(material.serialize());
                 } else if (material instanceof MultiMaterial) {
                     serializationObject.multiMaterials.push(serializeMultiMaterial(material));
                 }