Parse methods

Light, Camera, Updating .js files, updating babylon file loader

src/Bones/babylon.skeleton.js

@@ -103,6 +103,21 @@ var BABYLON;
             // Remove from scene
             this.getScene().removeSkeleton(this);
         };
+        Skeleton.ParseSkeleton = function (parsedSkeleton, scene) {
+            var skeleton = new BABYLON.Skeleton(parsedSkeleton.name, parsedSkeleton.id, scene);
+            for (var index = 0; index < parsedSkeleton.bones.length; index++) {
+                var parsedBone = parsedSkeleton.bones[index];
+                var parentBone = null;
+                if (parsedBone.parentBoneIndex > -1) {
+                    parentBone = skeleton.bones[parsedBone.parentBoneIndex];
+                }
+                var bone = new BABYLON.Bone(parsedBone.name, skeleton, parentBone, BABYLON.Matrix.FromArray(parsedBone.matrix));
+                if (parsedBone.animation) {
+                    bone.animations.push(BABYLON.Animation.ParseAnimation(parsedBone.animation));
+                }
+            }
+            return skeleton;
+        };
         return Skeleton;
     })();
     BABYLON.Skeleton = Skeleton;

src/Cameras/babylon.camera.js

@@ -516,6 +516,113 @@ var BABYLON;
                 this._rigCameras[0].viewport = this._rigCameras[1].viewport = this.viewport;
             }
         };
+        Camera.ParseCamera = function (parsedCamera, scene) {
+            var camera;
+            var position = BABYLON.Vector3.FromArray(parsedCamera.position);
+            var lockedTargetMesh = (parsedCamera.lockedTargetId) ? scene.getLastMeshByID(parsedCamera.lockedTargetId) : null;
+            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;
+                    camera = new BABYLON.AnaglyphArcRotateCamera(parsedCamera.name, alpha, beta, radius, lockedTargetMesh, interaxial_distance, scene);
+                }
+                else {
+                    camera = new BABYLON.ArcRotateCamera(parsedCamera.name, alpha, beta, radius, lockedTargetMesh, scene);
+                }
+            }
+            else if (parsedCamera.type === "AnaglyphFreeCamera") {
+                interaxial_distance = parsedCamera.interaxial_distance;
+                camera = new BABYLON.AnaglyphFreeCamera(parsedCamera.name, position, interaxial_distance, scene);
+            }
+            else if (parsedCamera.type === "DeviceOrientationCamera") {
+                camera = new BABYLON.DeviceOrientationCamera(parsedCamera.name, position, scene);
+            }
+            else if (parsedCamera.type === "FollowCamera") {
+                camera = new BABYLON.FollowCamera(parsedCamera.name, position, scene);
+                camera.heightOffset = parsedCamera.heightOffset;
+                camera.radius = parsedCamera.radius;
+                camera.rotationOffset = parsedCamera.rotationOffset;
+                if (lockedTargetMesh)
+                    camera.target = lockedTargetMesh;
+            }
+            else if (parsedCamera.type === "GamepadCamera") {
+                camera = new BABYLON.GamepadCamera(parsedCamera.name, position, scene);
+            }
+            else if (parsedCamera.type === "TouchCamera") {
+                camera = new BABYLON.TouchCamera(parsedCamera.name, position, scene);
+            }
+            else if (parsedCamera.type === "VirtualJoysticksCamera") {
+                camera = new BABYLON.VirtualJoysticksCamera(parsedCamera.name, position, scene);
+            }
+            else if (parsedCamera.type === "WebVRFreeCamera") {
+                camera = new BABYLON.WebVRFreeCamera(parsedCamera.name, position, scene);
+            }
+            else if (parsedCamera.type === "VRDeviceOrientationFreeCamera") {
+                camera = new BABYLON.VRDeviceOrientationFreeCamera(parsedCamera.name, position, scene);
+            }
+            else {
+                // Free Camera is the default value
+                camera = new BABYLON.FreeCamera(parsedCamera.name, position, scene);
+            }
+            // apply 3d rig, when found
+            if (parsedCamera.cameraRigMode) {
+                var rigParams = (parsedCamera.interaxial_distance) ? { interaxialDistance: parsedCamera.interaxial_distance } : {};
+                camera.setCameraRigMode(parsedCamera.cameraRigMode, rigParams);
+            }
+            // Test for lockedTargetMesh & FreeCamera outside of if-else-if nest, since things like GamepadCamera extend FreeCamera
+            if (lockedTargetMesh && camera instanceof BABYLON.FreeCamera) {
+                camera.lockedTarget = lockedTargetMesh;
+            }
+            camera.id = parsedCamera.id;
+            BABYLON.Tags.AddTagsTo(camera, parsedCamera.tags);
+            // Parent
+            if (parsedCamera.parentId) {
+                camera._waitingParentId = parsedCamera.parentId;
+            }
+            // Target
+            if (parsedCamera.target) {
+                if (camera.setTarget) {
+                    camera.setTarget(BABYLON.Vector3.FromArray(parsedCamera.target));
+                }
+                else {
+                    //For ArcRotate
+                    camera.target = BABYLON.Vector3.FromArray(parsedCamera.target);
+                }
+            }
+            else {
+                camera.rotation = BABYLON.Vector3.FromArray(parsedCamera.rotation);
+            }
+            camera.fov = parsedCamera.fov;
+            camera.minZ = parsedCamera.minZ;
+            camera.maxZ = parsedCamera.maxZ;
+            camera.speed = parsedCamera.speed;
+            camera.inertia = parsedCamera.inertia;
+            camera.checkCollisions = parsedCamera.checkCollisions;
+            camera.applyGravity = parsedCamera.applyGravity;
+            if (parsedCamera.ellipsoid) {
+                camera.ellipsoid = BABYLON.Vector3.FromArray(parsedCamera.ellipsoid);
+            }
+            // Animations
+            if (parsedCamera.animations) {
+                for (var animationIndex = 0; animationIndex < parsedCamera.animations.length; animationIndex++) {
+                    var parsedAnimation = parsedCamera.animations[animationIndex];
+                    camera.animations.push(BABYLON.Animation.ParseAnimation(parsedAnimation));
+                }
+            }
+            if (parsedCamera.autoAnimate) {
+                scene.beginAnimation(camera, parsedCamera.autoAnimateFrom, parsedCamera.autoAnimateTo, parsedCamera.autoAnimateLoop, 1.0);
+            }
+            // Layer Mask
+            if (parsedCamera.layerMask && (!isNaN(parsedCamera.layerMask))) {
+                camera.layerMask = Math.abs(parseInt(parsedCamera.layerMask));
+            }
+            else {
+                camera.layerMask = 0x0FFFFFFF;
+            }
+            return camera;
+        };
         // Statics
         Camera._PERSPECTIVE_CAMERA = 0;
         Camera._ORTHOGRAPHIC_CAMERA = 1;

src/Cameras/babylon.camera.ts

@@ -584,6 +584,125 @@
                 this._rigCameras[0].viewport = this._rigCameras[1].viewport = this.viewport;
             }
         }
+
+        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;
+
+            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;
+                    camera = new AnaglyphArcRotateCamera(parsedCamera.name, alpha, beta, radius, lockedTargetMesh, interaxial_distance, scene);
+                } else {
+                    camera = new ArcRotateCamera(parsedCamera.name, alpha, beta, radius, lockedTargetMesh, scene);
+                }
+
+            } else if (parsedCamera.type === "AnaglyphFreeCamera") {
+                interaxial_distance = parsedCamera.interaxial_distance;
+                camera = new AnaglyphFreeCamera(parsedCamera.name, position, interaxial_distance, scene);
+
+            } else if (parsedCamera.type === "DeviceOrientationCamera") {
+                camera = new DeviceOrientationCamera(parsedCamera.name, position, scene);
+
+            } else if (parsedCamera.type === "FollowCamera") {
+                camera = new FollowCamera(parsedCamera.name, position, scene);
+                camera.heightOffset = parsedCamera.heightOffset;
+                camera.radius = parsedCamera.radius;
+                camera.rotationOffset = parsedCamera.rotationOffset;
+                if (lockedTargetMesh)
+                    (<FollowCamera>camera).target = lockedTargetMesh;
+
+            } else if (parsedCamera.type === "GamepadCamera") {
+                camera = new GamepadCamera(parsedCamera.name, position, scene);
+
+            } else if (parsedCamera.type === "TouchCamera") {
+                camera = new TouchCamera(parsedCamera.name, position, scene);
+
+            } else if (parsedCamera.type === "VirtualJoysticksCamera") {
+                camera = new VirtualJoysticksCamera(parsedCamera.name, position, scene);
+
+            } else if (parsedCamera.type === "WebVRFreeCamera") {
+                camera = new WebVRFreeCamera(parsedCamera.name, position, scene);
+
+            } else if (parsedCamera.type === "VRDeviceOrientationFreeCamera") {
+                camera = new VRDeviceOrientationFreeCamera(parsedCamera.name, position, scene);
+
+            } else {
+                // Free Camera is the default value
+                camera = new FreeCamera(parsedCamera.name, position, scene);
+            }
+
+            // apply 3d rig, when found
+            if (parsedCamera.cameraRigMode) {
+                var rigParams = (parsedCamera.interaxial_distance) ? { interaxialDistance: parsedCamera.interaxial_distance } : {};
+                camera.setCameraRigMode(parsedCamera.cameraRigMode, rigParams);
+            }
+
+            // Test for lockedTargetMesh & FreeCamera outside of if-else-if nest, since things like GamepadCamera extend FreeCamera
+            if (lockedTargetMesh && camera instanceof FreeCamera) {
+                (<FreeCamera>camera).lockedTarget = lockedTargetMesh;
+            }
+
+            camera.id = parsedCamera.id;
+
+            Tags.AddTagsTo(camera, parsedCamera.tags);
+
+            // Parent
+            if (parsedCamera.parentId) {
+                camera._waitingParentId = parsedCamera.parentId;
+            }
+
+            // Target
+            if (parsedCamera.target) {
+                if (camera.setTarget) {
+                    camera.setTarget(Vector3.FromArray(parsedCamera.target));
+                } else {
+                    //For ArcRotate
+                    camera.target = Vector3.FromArray(parsedCamera.target);
+                }
+            } else {
+                camera.rotation = Vector3.FromArray(parsedCamera.rotation);
+            }
+
+            camera.fov = parsedCamera.fov;
+            camera.minZ = parsedCamera.minZ;
+            camera.maxZ = parsedCamera.maxZ;
+
+            camera.speed = parsedCamera.speed;
+            camera.inertia = parsedCamera.inertia;
+
+            camera.checkCollisions = parsedCamera.checkCollisions;
+            camera.applyGravity = parsedCamera.applyGravity;
+            if (parsedCamera.ellipsoid) {
+                camera.ellipsoid = Vector3.FromArray(parsedCamera.ellipsoid);
+            }
+
+            // Animations
+            if (parsedCamera.animations) {
+                for (var animationIndex = 0; animationIndex < parsedCamera.animations.length; animationIndex++) {
+                    var parsedAnimation = parsedCamera.animations[animationIndex];
+
+                    camera.animations.push(Animation.ParseAnimation(parsedAnimation));
+                }
+            }
+
+            if (parsedCamera.autoAnimate) {
+                scene.beginAnimation(camera, parsedCamera.autoAnimateFrom, parsedCamera.autoAnimateTo, parsedCamera.autoAnimateLoop, 1.0);
+            }
+
+            // Layer Mask
+            if (parsedCamera.layerMask && (!isNaN(parsedCamera.layerMask))) {
+                camera.layerMask = Math.abs(parseInt(parsedCamera.layerMask));
+            } else {
+                camera.layerMask = 0x0FFFFFFF;
+            }
+
+            return camera;
+        }
     }
 }
 

src/LensFlare/babylon.lensFlareSystem.js

@@ -176,6 +176,16 @@ var BABYLON;
             var index = this._scene.lensFlareSystems.indexOf(this);
             this._scene.lensFlareSystems.splice(index, 1);
         };
+        LensFlareSystem.ParseLensFlareSystem = function (parsedLensFlareSystem, scene, rootUrl) {
+            var emitter = scene.getLastEntryByID(parsedLensFlareSystem.emitterId);
+            var lensFlareSystem = new LensFlareSystem("lensFlareSystem#" + parsedLensFlareSystem.emitterId, emitter, scene);
+            lensFlareSystem.borderLimit = parsedLensFlareSystem.borderLimit;
+            for (var index = 0; index < parsedLensFlareSystem.flares.length; index++) {
+                var parsedFlare = parsedLensFlareSystem.flares[index];
+                var flare = new BABYLON.LensFlare(parsedFlare.size, parsedFlare.position, BABYLON.Color3.FromArray(parsedFlare.color), rootUrl + parsedFlare.textureName, lensFlareSystem);
+            }
+            return lensFlareSystem;
+        };
         return LensFlareSystem;
     })();
     BABYLON.LensFlareSystem = LensFlareSystem;

src/LensFlare/babylon.lensFlareSystem.ts

@@ -234,7 +234,7 @@
             this._scene.lensFlareSystems.splice(index, 1);
         }
         
-        public static ParseLensFlareSystem(parsedLensFlareSystem: any, scene: Scene, rootUrl: string): LensFlare {
+        public static ParseLensFlareSystem(parsedLensFlareSystem: any, scene: Scene, rootUrl: string): LensFlareSystem {
             var emitter = scene.getLastEntryByID(parsedLensFlareSystem.emitterId);
 
             var lensFlareSystem = new LensFlareSystem("lensFlareSystem#" + parsedLensFlareSystem.emitterId, emitter, scene);

src/Lights/Shadows/babylon.shadowGenerator.js

@@ -338,6 +338,34 @@ var BABYLON;
                 this._boxBlurPostprocess.dispose();
             }
         };
+        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);
+            var shadowGenerator = new ShadowGenerator(parsedShadowGenerator.mapSize, light);
+            for (var meshIndex = 0; meshIndex < parsedShadowGenerator.renderList.length; meshIndex++) {
+                var mesh = scene.getMeshByID(parsedShadowGenerator.renderList[meshIndex]);
+                shadowGenerator.getShadowMap().renderList.push(mesh);
+            }
+            if (parsedShadowGenerator.usePoissonSampling) {
+                shadowGenerator.usePoissonSampling = true;
+            }
+            else if (parsedShadowGenerator.useVarianceShadowMap) {
+                shadowGenerator.useVarianceShadowMap = true;
+            }
+            else if (parsedShadowGenerator.useBlurVarianceShadowMap) {
+                shadowGenerator.useBlurVarianceShadowMap = true;
+                if (parsedShadowGenerator.blurScale) {
+                    shadowGenerator.blurScale = parsedShadowGenerator.blurScale;
+                }
+                if (parsedShadowGenerator.blurBoxOffset) {
+                    shadowGenerator.blurBoxOffset = parsedShadowGenerator.blurBoxOffset;
+                }
+            }
+            if (parsedShadowGenerator.bias !== undefined) {
+                shadowGenerator.bias = parsedShadowGenerator.bias;
+            }
+            return shadowGenerator;
+        };
         ShadowGenerator._FILTER_NONE = 0;
         ShadowGenerator._FILTER_VARIANCESHADOWMAP = 1;
         ShadowGenerator._FILTER_POISSONSAMPLING = 2;

src/Lights/Shadows/babylon.shadowGenerator.ts

@@ -393,7 +393,8 @@
         }
 
         public static ParseShadowGenerator(parsedShadowGenerator: any, scene: Scene): ShadowGenerator {
-            var light = scene.getLightByID(parsedShadowGenerator.lightId);
+            //casting to point light, as light is missing the position attr and typescript complains.
+            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.light.js

@@ -73,6 +73,56 @@ var BABYLON;
             // Remove from scene
             this.getScene().removeLight(this);
         };
+        Light.ParseLight = function (parsedLight, scene) {
+            var light;
+            switch (parsedLight.type) {
+                case 0:
+                    light = new BABYLON.PointLight(parsedLight.name, BABYLON.Vector3.FromArray(parsedLight.position), scene);
+                    break;
+                case 1:
+                    light = new BABYLON.DirectionalLight(parsedLight.name, BABYLON.Vector3.FromArray(parsedLight.direction), scene);
+                    light.position = BABYLON.Vector3.FromArray(parsedLight.position);
+                    break;
+                case 2:
+                    light = new BABYLON.SpotLight(parsedLight.name, BABYLON.Vector3.FromArray(parsedLight.position), BABYLON.Vector3.FromArray(parsedLight.direction), parsedLight.angle, parsedLight.exponent, scene);
+                    break;
+                case 3:
+                    light = new BABYLON.HemisphericLight(parsedLight.name, BABYLON.Vector3.FromArray(parsedLight.direction), scene);
+                    light.groundColor = BABYLON.Color3.FromArray(parsedLight.groundColor);
+                    break;
+            }
+            light.id = parsedLight.id;
+            BABYLON.Tags.AddTagsTo(light, parsedLight.tags);
+            if (parsedLight.intensity !== undefined) {
+                light.intensity = parsedLight.intensity;
+            }
+            if (parsedLight.range) {
+                light.range = parsedLight.range;
+            }
+            light.diffuse = BABYLON.Color3.FromArray(parsedLight.diffuse);
+            light.specular = BABYLON.Color3.FromArray(parsedLight.specular);
+            if (parsedLight.excludedMeshesIds) {
+                light._excludedMeshesIds = parsedLight.excludedMeshesIds;
+            }
+            // Parent
+            if (parsedLight.parentId) {
+                light._waitingParentId = parsedLight.parentId;
+            }
+            if (parsedLight.includedOnlyMeshesIds) {
+                light._includedOnlyMeshesIds = parsedLight.includedOnlyMeshesIds;
+            }
+            // Animations
+            if (parsedLight.animations) {
+                for (var animationIndex = 0; animationIndex < parsedLight.animations.length; animationIndex++) {
+                    var parsedAnimation = parsedLight.animations[animationIndex];
+                    light.animations.push(BABYLON.Animation.ParseAnimation(parsedAnimation));
+                }
+            }
+            if (parsedLight.autoAnimate) {
+                scene.beginAnimation(light, parsedLight.autoAnimateFrom, parsedLight.autoAnimateTo, parsedLight.autoAnimateLoop, 1.0);
+            }
+            return light;
+        };
         return Light;
     })(BABYLON.Node);
     BABYLON.Light = Light;

src/Lights/babylon.light.ts

@@ -112,5 +112,69 @@
             // Remove from scene
             this.getScene().removeLight(this);
         }
+
+        public static ParseLight(parsedLight: any, scene: Scene): Light {
+            var light;
+
+            switch (parsedLight.type) {
+                case 0:
+                    light = new PointLight(parsedLight.name, Vector3.FromArray(parsedLight.position), scene);
+                    break;
+                case 1:
+                    light = new DirectionalLight(parsedLight.name, Vector3.FromArray(parsedLight.direction), scene);
+                    light.position = Vector3.FromArray(parsedLight.position);
+                    break;
+                case 2:
+                    light = new SpotLight(parsedLight.name, Vector3.FromArray(parsedLight.position), Vector3.FromArray(parsedLight.direction), parsedLight.angle, parsedLight.exponent, scene);
+                    break;
+                case 3:
+                    light = new HemisphericLight(parsedLight.name, Vector3.FromArray(parsedLight.direction), scene);
+                    light.groundColor = Color3.FromArray(parsedLight.groundColor);
+                    break;
+            }
+
+            light.id = parsedLight.id;
+
+            Tags.AddTagsTo(light, parsedLight.tags);
+
+            if (parsedLight.intensity !== undefined) {
+                light.intensity = parsedLight.intensity;
+            }
+
+            if (parsedLight.range) {
+                light.range = parsedLight.range;
+            }
+
+            light.diffuse = Color3.FromArray(parsedLight.diffuse);
+            light.specular = Color3.FromArray(parsedLight.specular);
+
+            if (parsedLight.excludedMeshesIds) {
+                light._excludedMeshesIds = parsedLight.excludedMeshesIds;
+            }
+
+            // Parent
+            if (parsedLight.parentId) {
+                light._waitingParentId = parsedLight.parentId;
+            }
+
+            if (parsedLight.includedOnlyMeshesIds) {
+                light._includedOnlyMeshesIds = parsedLight.includedOnlyMeshesIds;
+            }
+
+            // Animations
+            if (parsedLight.animations) {
+                for (var animationIndex = 0; animationIndex < parsedLight.animations.length; animationIndex++) {
+                    var parsedAnimation = parsedLight.animations[animationIndex];
+
+                    light.animations.push(Animation.ParseAnimation(parsedAnimation));
+                }
+            }
+
+            if (parsedLight.autoAnimate) {
+                scene.beginAnimation(light, parsedLight.autoAnimateFrom, parsedLight.autoAnimateTo, parsedLight.autoAnimateLoop, 1.0);
+            }
+            
+            return light;
+        }
     }
 } 

src/Loading/Plugins/babylon.babylonFileLoader.js

@@ -17,277 +17,15 @@ var BABYLON;
             }
             return colors;
         };
-        var parseSkeleton = function (parsedSkeleton, scene) {
-            var skeleton = new BABYLON.Skeleton(parsedSkeleton.name, parsedSkeleton.id, scene);
-            for (var index = 0; index < parsedSkeleton.bones.length; index++) {
-                var parsedBone = parsedSkeleton.bones[index];
-                var parentBone = null;
-                if (parsedBone.parentBoneIndex > -1) {
-                    parentBone = skeleton.bones[parsedBone.parentBoneIndex];
-                }
-                var bone = new BABYLON.Bone(parsedBone.name, skeleton, parentBone, BABYLON.Matrix.FromArray(parsedBone.matrix));
-                if (parsedBone.animation) {
-                    bone.animations.push(BABYLON.Animation.ParseAnimation(parsedBone.animation));
-                }
-            }
-            return skeleton;
-        };
-        var parseCustomMaterial = function (parsedMaterial, scene, rootUrl) {
-            return null;
-        };
-        var parseMaterial = function (parsedMaterial, scene, rootUrl) {
-            if (!parsedMaterial.customType) {
-                return BABYLON.StandardMaterial.Parse(parsedMaterial, scene, rootUrl);
-            }
-            return parseCustomMaterial(parsedMaterial, scene, rootUrl);
-        };
         var parseMaterialById = function (id, parsedData, scene, rootUrl) {
             for (var index = 0; index < parsedData.materials.length; index++) {
                 var parsedMaterial = parsedData.materials[index];
                 if (parsedMaterial.id === id) {
-                    return parseMaterial(parsedMaterial, scene, rootUrl);
+                    return BABYLON.Material.ParseMaterial(parsedMaterial, scene, rootUrl);
                 }
             }
             return null;
         };
-        var parseMultiMaterial = function (parsedMultiMaterial, scene) {
-            var multiMaterial = new BABYLON.MultiMaterial(parsedMultiMaterial.name, scene);
-            multiMaterial.id = parsedMultiMaterial.id;
-            BABYLON.Tags.AddTagsTo(multiMaterial, parsedMultiMaterial.tags);
-            for (var matIndex = 0; matIndex < parsedMultiMaterial.materials.length; matIndex++) {
-                var subMatId = parsedMultiMaterial.materials[matIndex];
-                if (subMatId) {
-                    multiMaterial.subMaterials.push(scene.getMaterialByID(subMatId));
-                }
-                else {
-                    multiMaterial.subMaterials.push(null);
-                }
-            }
-            return multiMaterial;
-        };
-        var parseLensFlareSystem = function (parsedLensFlareSystem, scene, rootUrl) {
-            var emitter = scene.getLastEntryByID(parsedLensFlareSystem.emitterId);
-            var lensFlareSystem = new BABYLON.LensFlareSystem("lensFlareSystem#" + parsedLensFlareSystem.emitterId, emitter, scene);
-            lensFlareSystem.borderLimit = parsedLensFlareSystem.borderLimit;
-            for (var index = 0; index < parsedLensFlareSystem.flares.length; index++) {
-                var parsedFlare = parsedLensFlareSystem.flares[index];
-                var flare = new BABYLON.LensFlare(parsedFlare.size, parsedFlare.position, BABYLON.Color3.FromArray(parsedFlare.color), rootUrl + parsedFlare.textureName, lensFlareSystem);
-            }
-            return lensFlareSystem;
-        };
-        var parseParticleSystem = function (parsedParticleSystem, scene, rootUrl) {
-            var emitter = scene.getLastMeshByID(parsedParticleSystem.emitterId);
-            var particleSystem = new BABYLON.ParticleSystem("particles#" + emitter.name, parsedParticleSystem.capacity, scene);
-            if (parsedParticleSystem.textureName) {
-                particleSystem.particleTexture = new BABYLON.Texture(rootUrl + parsedParticleSystem.textureName, scene);
-                particleSystem.particleTexture.name = parsedParticleSystem.textureName;
-            }
-            particleSystem.minAngularSpeed = parsedParticleSystem.minAngularSpeed;
-            particleSystem.maxAngularSpeed = parsedParticleSystem.maxAngularSpeed;
-            particleSystem.minSize = parsedParticleSystem.minSize;
-            particleSystem.maxSize = parsedParticleSystem.maxSize;
-            particleSystem.minLifeTime = parsedParticleSystem.minLifeTime;
-            particleSystem.maxLifeTime = parsedParticleSystem.maxLifeTime;
-            particleSystem.emitter = emitter;
-            particleSystem.emitRate = parsedParticleSystem.emitRate;
-            particleSystem.minEmitBox = BABYLON.Vector3.FromArray(parsedParticleSystem.minEmitBox);
-            particleSystem.maxEmitBox = BABYLON.Vector3.FromArray(parsedParticleSystem.maxEmitBox);
-            particleSystem.gravity = BABYLON.Vector3.FromArray(parsedParticleSystem.gravity);
-            particleSystem.direction1 = BABYLON.Vector3.FromArray(parsedParticleSystem.direction1);
-            particleSystem.direction2 = BABYLON.Vector3.FromArray(parsedParticleSystem.direction2);
-            particleSystem.color1 = BABYLON.Color4.FromArray(parsedParticleSystem.color1);
-            particleSystem.color2 = BABYLON.Color4.FromArray(parsedParticleSystem.color2);
-            particleSystem.colorDead = BABYLON.Color4.FromArray(parsedParticleSystem.colorDead);
-            particleSystem.updateSpeed = parsedParticleSystem.updateSpeed;
-            particleSystem.targetStopDuration = parsedParticleSystem.targetStopFrame;
-            particleSystem.textureMask = BABYLON.Color4.FromArray(parsedParticleSystem.textureMask);
-            particleSystem.blendMode = parsedParticleSystem.blendMode;
-            particleSystem.start();
-            return particleSystem;
-        };
-        var parseShadowGenerator = function (parsedShadowGenerator, scene) {
-            var light = scene.getLightByID(parsedShadowGenerator.lightId);
-            var shadowGenerator = new BABYLON.ShadowGenerator(parsedShadowGenerator.mapSize, light);
-            for (var meshIndex = 0; meshIndex < parsedShadowGenerator.renderList.length; meshIndex++) {
-                var mesh = scene.getMeshByID(parsedShadowGenerator.renderList[meshIndex]);
-                shadowGenerator.getShadowMap().renderList.push(mesh);
-            }
-            if (parsedShadowGenerator.usePoissonSampling) {
-                shadowGenerator.usePoissonSampling = true;
-            }
-            else if (parsedShadowGenerator.useVarianceShadowMap) {
-                shadowGenerator.useVarianceShadowMap = true;
-            }
-            else if (parsedShadowGenerator.useBlurVarianceShadowMap) {
-                shadowGenerator.useBlurVarianceShadowMap = true;
-                if (parsedShadowGenerator.blurScale) {
-                    shadowGenerator.blurScale = parsedShadowGenerator.blurScale;
-                }
-                if (parsedShadowGenerator.blurBoxOffset) {
-                    shadowGenerator.blurBoxOffset = parsedShadowGenerator.blurBoxOffset;
-                }
-            }
-            if (parsedShadowGenerator.bias !== undefined) {
-                shadowGenerator.bias = parsedShadowGenerator.bias;
-            }
-            return shadowGenerator;
-        };
-        var parseLight = function (parsedLight, scene) {
-            var light;
-            switch (parsedLight.type) {
-                case 0:
-                    light = new BABYLON.PointLight(parsedLight.name, BABYLON.Vector3.FromArray(parsedLight.position), scene);
-                    break;
-                case 1:
-                    light = new BABYLON.DirectionalLight(parsedLight.name, BABYLON.Vector3.FromArray(parsedLight.direction), scene);
-                    light.position = BABYLON.Vector3.FromArray(parsedLight.position);
-                    break;
-                case 2:
-                    light = new BABYLON.SpotLight(parsedLight.name, BABYLON.Vector3.FromArray(parsedLight.position), BABYLON.Vector3.FromArray(parsedLight.direction), parsedLight.angle, parsedLight.exponent, scene);
-                    break;
-                case 3:
-                    light = new BABYLON.HemisphericLight(parsedLight.name, BABYLON.Vector3.FromArray(parsedLight.direction), scene);
-                    light.groundColor = BABYLON.Color3.FromArray(parsedLight.groundColor);
-                    break;
-            }
-            light.id = parsedLight.id;
-            BABYLON.Tags.AddTagsTo(light, parsedLight.tags);
-            if (parsedLight.intensity !== undefined) {
-                light.intensity = parsedLight.intensity;
-            }
-            if (parsedLight.range) {
-                light.range = parsedLight.range;
-            }
-            light.diffuse = BABYLON.Color3.FromArray(parsedLight.diffuse);
-            light.specular = BABYLON.Color3.FromArray(parsedLight.specular);
-            if (parsedLight.excludedMeshesIds) {
-                light._excludedMeshesIds = parsedLight.excludedMeshesIds;
-            }
-            // Parent
-            if (parsedLight.parentId) {
-                light._waitingParentId = parsedLight.parentId;
-            }
-            if (parsedLight.includedOnlyMeshesIds) {
-                light._includedOnlyMeshesIds = parsedLight.includedOnlyMeshesIds;
-            }
-            // Animations
-            if (parsedLight.animations) {
-                for (var animationIndex = 0; animationIndex < parsedLight.animations.length; animationIndex++) {
-                    var parsedAnimation = parsedLight.animations[animationIndex];
-                    light.animations.push(BABYLON.Animation.ParseAnimation(parsedAnimation));
-                }
-            }
-            if (parsedLight.autoAnimate) {
-                scene.beginAnimation(light, parsedLight.autoAnimateFrom, parsedLight.autoAnimateTo, parsedLight.autoAnimateLoop, 1.0);
-            }
-        };
-        var parseCamera = function (parsedCamera, scene) {
-            var camera;
-            var position = BABYLON.Vector3.FromArray(parsedCamera.position);
-            var lockedTargetMesh = (parsedCamera.lockedTargetId) ? scene.getLastMeshByID(parsedCamera.lockedTargetId) : null;
-            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;
-                    camera = new BABYLON.AnaglyphArcRotateCamera(parsedCamera.name, alpha, beta, radius, lockedTargetMesh, interaxial_distance, scene);
-                }
-                else {
-                    camera = new BABYLON.ArcRotateCamera(parsedCamera.name, alpha, beta, radius, lockedTargetMesh, scene);
-                }
-            }
-            else if (parsedCamera.type === "AnaglyphFreeCamera") {
-                interaxial_distance = parsedCamera.interaxial_distance;
-                camera = new BABYLON.AnaglyphFreeCamera(parsedCamera.name, position, interaxial_distance, scene);
-            }
-            else if (parsedCamera.type === "DeviceOrientationCamera") {
-                camera = new BABYLON.DeviceOrientationCamera(parsedCamera.name, position, scene);
-            }
-            else if (parsedCamera.type === "FollowCamera") {
-                camera = new BABYLON.FollowCamera(parsedCamera.name, position, scene);
-                camera.heightOffset = parsedCamera.heightOffset;
-                camera.radius = parsedCamera.radius;
-                camera.rotationOffset = parsedCamera.rotationOffset;
-                if (lockedTargetMesh)
-                    camera.target = lockedTargetMesh;
-            }
-            else if (parsedCamera.type === "GamepadCamera") {
-                camera = new BABYLON.GamepadCamera(parsedCamera.name, position, scene);
-            }
-            else if (parsedCamera.type === "TouchCamera") {
-                camera = new BABYLON.TouchCamera(parsedCamera.name, position, scene);
-            }
-            else if (parsedCamera.type === "VirtualJoysticksCamera") {
-                camera = new BABYLON.VirtualJoysticksCamera(parsedCamera.name, position, scene);
-            }
-            else if (parsedCamera.type === "WebVRFreeCamera") {
-                camera = new BABYLON.WebVRFreeCamera(parsedCamera.name, position, scene);
-            }
-            else if (parsedCamera.type === "VRDeviceOrientationFreeCamera") {
-                camera = new BABYLON.VRDeviceOrientationFreeCamera(parsedCamera.name, position, scene);
-            }
-            else {
-                // Free Camera is the default value
-                camera = new BABYLON.FreeCamera(parsedCamera.name, position, scene);
-            }
-            // apply 3d rig, when found
-            if (parsedCamera.cameraRigMode) {
-                var rigParams = (parsedCamera.interaxial_distance) ? { interaxialDistance: parsedCamera.interaxial_distance } : {};
-                camera.setCameraRigMode(parsedCamera.cameraRigMode, rigParams);
-            }
-            // Test for lockedTargetMesh & FreeCamera outside of if-else-if nest, since things like GamepadCamera extend FreeCamera
-            if (lockedTargetMesh && camera instanceof BABYLON.FreeCamera) {
-                camera.lockedTarget = lockedTargetMesh;
-            }
-            camera.id = parsedCamera.id;
-            BABYLON.Tags.AddTagsTo(camera, parsedCamera.tags);
-            // Parent
-            if (parsedCamera.parentId) {
-                camera._waitingParentId = parsedCamera.parentId;
-            }
-            // Target
-            if (parsedCamera.target) {
-                if (camera.setTarget) {
-                    camera.setTarget(BABYLON.Vector3.FromArray(parsedCamera.target));
-                }
-                else {
-                    //For ArcRotate
-                    camera.target = BABYLON.Vector3.FromArray(parsedCamera.target);
-                }
-            }
-            else {
-                camera.rotation = BABYLON.Vector3.FromArray(parsedCamera.rotation);
-            }
-            camera.fov = parsedCamera.fov;
-            camera.minZ = parsedCamera.minZ;
-            camera.maxZ = parsedCamera.maxZ;
-            camera.speed = parsedCamera.speed;
-            camera.inertia = parsedCamera.inertia;
-            camera.checkCollisions = parsedCamera.checkCollisions;
-            camera.applyGravity = parsedCamera.applyGravity;
-            if (parsedCamera.ellipsoid) {
-                camera.ellipsoid = BABYLON.Vector3.FromArray(parsedCamera.ellipsoid);
-            }
-            // Animations
-            if (parsedCamera.animations) {
-                for (var animationIndex = 0; animationIndex < parsedCamera.animations.length; animationIndex++) {
-                    var parsedAnimation = parsedCamera.animations[animationIndex];
-                    camera.animations.push(BABYLON.Animation.ParseAnimation(parsedAnimation));
-                }
-            }
-            if (parsedCamera.autoAnimate) {
-                scene.beginAnimation(camera, parsedCamera.autoAnimateFrom, parsedCamera.autoAnimateTo, parsedCamera.autoAnimateLoop, 1.0);
-            }
-            // Layer Mask
-            if (parsedCamera.layerMask && (!isNaN(parsedCamera.layerMask))) {
-                camera.layerMask = Math.abs(parseInt(parsedCamera.layerMask));
-            }
-            else {
-                camera.layerMask = 0x0FFFFFFF;
-            }
-            return camera;
-        };
         var parseGeometry = function (parsedGeometry, scene) {
             var id = parsedGeometry.id;
             return scene.getGeometryByID(id);
@@ -1056,7 +794,7 @@ var BABYLON;
                                             parseMaterialById(subMatId, parsedData, scene, rootUrl);
                                         }
                                         loadedMaterialsIds.push(parsedMultiMaterial.id);
-                                        parseMultiMaterial(parsedMultiMaterial, scene);
+                                        parsedMultiMaterial.ParseMultiMaterial(parsedMultiMaterial, scene);
                                         materialFound = true;
                                         break;
                                     }
@@ -1076,7 +814,7 @@ var BABYLON;
                                 for (var skeletonIndex = 0; skeletonIndex < parsedData.skeletons.length; skeletonIndex++) {
                                     var parsedSkeleton = parsedData.skeletons[skeletonIndex];
                                     if (parsedSkeleton.id === parsedMesh.skeletonId) {
-                                        skeletons.push(parseSkeleton(parsedSkeleton, scene));
+                                        skeletons.push(BABYLON.Skeleton.ParseSkeleton(parsedSkeleton, scene));
                                         loadedSkeletonsIds.push(parsedSkeleton.id);
                                     }
                                 }
@@ -1108,7 +846,7 @@ var BABYLON;
                     for (index = 0; index < parsedData.particleSystems.length; index++) {
                         var parsedParticleSystem = parsedData.particleSystems[index];
                         if (hierarchyIds.indexOf(parsedParticleSystem.emitterId) !== -1) {
-                            particleSystems.push(parseParticleSystem(parsedParticleSystem, scene, rootUrl));
+                            particleSystems.push(BABYLON.ParticleSystem.ParseParticleSystem(parsedParticleSystem, scene, rootUrl));
                         }
                     }
                 }
@@ -1154,26 +892,26 @@ var BABYLON;
                 var index;
                 for (index = 0; index < parsedData.lights.length; index++) {
                     var parsedLight = parsedData.lights[index];
-                    parseLight(parsedLight, scene);
+                    BABYLON.Light.ParseLight(parsedLight, scene);
                 }
                 // Materials
                 if (parsedData.materials) {
                     for (index = 0; index < parsedData.materials.length; index++) {
                         var parsedMaterial = parsedData.materials[index];
-                        parseMaterial(parsedMaterial, scene, rootUrl);
+                        BABYLON.Material.ParseMaterial(parsedMaterial, scene, rootUrl);
                     }
                 }
                 if (parsedData.multiMaterials) {
                     for (index = 0; index < parsedData.multiMaterials.length; index++) {
                         var parsedMultiMaterial = parsedData.multiMaterials[index];
-                        parseMultiMaterial(parsedMultiMaterial, scene);
+                        BABYLON.MultiMaterial.ParseMultiMaterial(parsedMultiMaterial, scene);
                     }
                 }
                 // Skeletons
                 if (parsedData.skeletons) {
                     for (index = 0; index < parsedData.skeletons.length; index++) {
                         var parsedSkeleton = parsedData.skeletons[index];
-                        parseSkeleton(parsedSkeleton, scene);
+                        BABYLON.Skeleton.ParseSkeleton(parsedSkeleton, scene);
                     }
                 }
                 // Geometries
@@ -1252,7 +990,7 @@ var BABYLON;
                 // Cameras
                 for (index = 0; index < parsedData.cameras.length; index++) {
                     var parsedCamera = parsedData.cameras[index];
-                    parseCamera(parsedCamera, scene);
+                    BABYLON.Camera.ParseCamera(parsedCamera, scene);
                 }
                 if (parsedData.activeCameraID) {
                     scene.setActiveCameraByID(parsedData.activeCameraID);
@@ -1308,21 +1046,21 @@ var BABYLON;
                 if (parsedData.particleSystems) {
                     for (index = 0; index < parsedData.particleSystems.length; index++) {
                         var parsedParticleSystem = parsedData.particleSystems[index];
-                        parseParticleSystem(parsedParticleSystem, scene, rootUrl);
+                        BABYLON.ParticleSystem.ParseParticleSystem(parsedParticleSystem, scene, rootUrl);
                     }
                 }
                 // Lens flares
                 if (parsedData.lensFlareSystems) {
                     for (index = 0; index < parsedData.lensFlareSystems.length; index++) {
                         var parsedLensFlareSystem = parsedData.lensFlareSystems[index];
-                        parseLensFlareSystem(parsedLensFlareSystem, scene, rootUrl);
+                        BABYLON.LensFlareSystem.ParseLensFlareSystem(parsedLensFlareSystem, scene, rootUrl);
                     }
                 }
                 // Shadows
                 if (parsedData.shadowGenerators) {
                     for (index = 0; index < parsedData.shadowGenerators.length; index++) {
                         var parsedShadowGenerator = parsedData.shadowGenerators[index];
-                        parseShadowGenerator(parsedShadowGenerator, scene);
+                        BABYLON.ShadowGenerator.ParseShadowGenerator(parsedShadowGenerator, scene);
                     }
                 }
                 // Actions (scene)

src/Loading/Plugins/babylon.babylonFileLoader.ts

@@ -17,332 +17,18 @@
 
         return colors;
     }
-    
-    var parseSkeleton = (parsedSkeleton, scene) => {
-        var skeleton = new BABYLON.Skeleton(parsedSkeleton.name, parsedSkeleton.id, scene);
-
-        for (var index = 0; index < parsedSkeleton.bones.length; index++) {
-            var parsedBone = parsedSkeleton.bones[index];
-
-            var parentBone = null;
-            if (parsedBone.parentBoneIndex > -1) {
-                parentBone = skeleton.bones[parsedBone.parentBoneIndex];
-            }
-
-            var bone = new BABYLON.Bone(parsedBone.name, skeleton, parentBone, BABYLON.Matrix.FromArray(parsedBone.matrix));
-
-            if (parsedBone.animation) {
-                bone.animations.push(Animation.ParseAnimation(parsedBone.animation));
-            }
-        }
-
-        return skeleton;
-    };    
-
-    var parseCustomMaterial = (parsedMaterial, scene, rootUrl): Material => {
-        return null;
-    }
-
-    var parseMaterial = (parsedMaterial, scene, rootUrl): Material => {
-        if (!parsedMaterial.customType) {
-            return StandardMaterial.Parse(parsedMaterial, scene, rootUrl);
-        }
-
-        return parseCustomMaterial(parsedMaterial, scene, rootUrl);
-    }
 
     var parseMaterialById = (id, parsedData, scene, rootUrl) => {
         for (var index = 0; index < parsedData.materials.length; index++) {
             var parsedMaterial = parsedData.materials[index];
             if (parsedMaterial.id === id) {
-                return parseMaterial(parsedMaterial, scene, rootUrl);
+                return BABYLON.Material.ParseMaterial(parsedMaterial, scene, rootUrl);
             }
         }
 
         return null;
     };
 
-    var parseMultiMaterial = (parsedMultiMaterial, scene) => {
-        var multiMaterial = new BABYLON.MultiMaterial(parsedMultiMaterial.name, scene);
-
-        multiMaterial.id = parsedMultiMaterial.id;
-
-        BABYLON.Tags.AddTagsTo(multiMaterial, parsedMultiMaterial.tags);
-
-        for (var matIndex = 0; matIndex < parsedMultiMaterial.materials.length; matIndex++) {
-            var subMatId = parsedMultiMaterial.materials[matIndex];
-
-            if (subMatId) {
-                multiMaterial.subMaterials.push(scene.getMaterialByID(subMatId));
-            } else {
-                multiMaterial.subMaterials.push(null);
-            }
-        }
-
-        return multiMaterial;
-    };
-
-    var parseLensFlareSystem = (parsedLensFlareSystem, scene, rootUrl) => {
-        var emitter = scene.getLastEntryByID(parsedLensFlareSystem.emitterId);
-
-        var lensFlareSystem = new BABYLON.LensFlareSystem("lensFlareSystem#" + parsedLensFlareSystem.emitterId, emitter, scene);
-        lensFlareSystem.borderLimit = parsedLensFlareSystem.borderLimit;
-
-        for (var index = 0; index < parsedLensFlareSystem.flares.length; index++) {
-            var parsedFlare = parsedLensFlareSystem.flares[index];
-            var flare = new BABYLON.LensFlare(parsedFlare.size, parsedFlare.position, BABYLON.Color3.FromArray(parsedFlare.color), rootUrl + parsedFlare.textureName, lensFlareSystem);
-        }
-
-        return lensFlareSystem;
-    };
-
-    var parseParticleSystem = (parsedParticleSystem, scene, rootUrl) => {
-        var emitter = scene.getLastMeshByID(parsedParticleSystem.emitterId);
-
-        var particleSystem = new BABYLON.ParticleSystem("particles#" + emitter.name, parsedParticleSystem.capacity, scene);
-        if (parsedParticleSystem.textureName) {
-            particleSystem.particleTexture = new BABYLON.Texture(rootUrl + parsedParticleSystem.textureName, scene);
-            particleSystem.particleTexture.name = parsedParticleSystem.textureName;
-        }
-        particleSystem.minAngularSpeed = parsedParticleSystem.minAngularSpeed;
-        particleSystem.maxAngularSpeed = parsedParticleSystem.maxAngularSpeed;
-        particleSystem.minSize = parsedParticleSystem.minSize;
-        particleSystem.maxSize = parsedParticleSystem.maxSize;
-        particleSystem.minLifeTime = parsedParticleSystem.minLifeTime;
-        particleSystem.maxLifeTime = parsedParticleSystem.maxLifeTime;
-        particleSystem.emitter = emitter;
-        particleSystem.emitRate = parsedParticleSystem.emitRate;
-        particleSystem.minEmitBox = BABYLON.Vector3.FromArray(parsedParticleSystem.minEmitBox);
-        particleSystem.maxEmitBox = BABYLON.Vector3.FromArray(parsedParticleSystem.maxEmitBox);
-        particleSystem.gravity = BABYLON.Vector3.FromArray(parsedParticleSystem.gravity);
-        particleSystem.direction1 = BABYLON.Vector3.FromArray(parsedParticleSystem.direction1);
-        particleSystem.direction2 = BABYLON.Vector3.FromArray(parsedParticleSystem.direction2);
-        particleSystem.color1 = BABYLON.Color4.FromArray(parsedParticleSystem.color1);
-        particleSystem.color2 = BABYLON.Color4.FromArray(parsedParticleSystem.color2);
-        particleSystem.colorDead = BABYLON.Color4.FromArray(parsedParticleSystem.colorDead);
-        particleSystem.updateSpeed = parsedParticleSystem.updateSpeed;
-        particleSystem.targetStopDuration = parsedParticleSystem.targetStopFrame;
-        particleSystem.textureMask = BABYLON.Color4.FromArray(parsedParticleSystem.textureMask);
-        particleSystem.blendMode = parsedParticleSystem.blendMode;
-        particleSystem.start();
-
-        return particleSystem;
-    };
-
-    var parseShadowGenerator = (parsedShadowGenerator, scene) => {
-        var light = scene.getLightByID(parsedShadowGenerator.lightId);
-        var shadowGenerator = new BABYLON.ShadowGenerator(parsedShadowGenerator.mapSize, light);
-
-        for (var meshIndex = 0; meshIndex < parsedShadowGenerator.renderList.length; meshIndex++) {
-            var mesh = scene.getMeshByID(parsedShadowGenerator.renderList[meshIndex]);
-
-            shadowGenerator.getShadowMap().renderList.push(mesh);
-        }
-
-        if (parsedShadowGenerator.usePoissonSampling) {
-            shadowGenerator.usePoissonSampling = true;
-        } else if (parsedShadowGenerator.useVarianceShadowMap) {
-            shadowGenerator.useVarianceShadowMap = true;
-        } else if (parsedShadowGenerator.useBlurVarianceShadowMap) {
-            shadowGenerator.useBlurVarianceShadowMap = true;
-
-            if (parsedShadowGenerator.blurScale) {
-                shadowGenerator.blurScale = parsedShadowGenerator.blurScale;
-            }
-
-            if (parsedShadowGenerator.blurBoxOffset) {
-                shadowGenerator.blurBoxOffset = parsedShadowGenerator.blurBoxOffset;
-            }
-        }
-
-        if (parsedShadowGenerator.bias !== undefined) {
-            shadowGenerator.bias = parsedShadowGenerator.bias;
-        }
-
-        return shadowGenerator;
-    };
-
-    var parseLight = (parsedLight, scene) => {
-        var light;
-
-        switch (parsedLight.type) {
-            case 0:
-                light = new BABYLON.PointLight(parsedLight.name, BABYLON.Vector3.FromArray(parsedLight.position), scene);
-                break;
-            case 1:
-                light = new BABYLON.DirectionalLight(parsedLight.name, BABYLON.Vector3.FromArray(parsedLight.direction), scene);
-                light.position = BABYLON.Vector3.FromArray(parsedLight.position);
-                break;
-            case 2:
-                light = new BABYLON.SpotLight(parsedLight.name, BABYLON.Vector3.FromArray(parsedLight.position), BABYLON.Vector3.FromArray(parsedLight.direction), parsedLight.angle, parsedLight.exponent, scene);
-                break;
-            case 3:
-                light = new BABYLON.HemisphericLight(parsedLight.name, BABYLON.Vector3.FromArray(parsedLight.direction), scene);
-                light.groundColor = BABYLON.Color3.FromArray(parsedLight.groundColor);
-                break;
-        }
-
-        light.id = parsedLight.id;
-
-        BABYLON.Tags.AddTagsTo(light, parsedLight.tags);
-
-        if (parsedLight.intensity !== undefined) {
-            light.intensity = parsedLight.intensity;
-        }
-
-        if (parsedLight.range) {
-            light.range = parsedLight.range;
-        }
-
-        light.diffuse = BABYLON.Color3.FromArray(parsedLight.diffuse);
-        light.specular = BABYLON.Color3.FromArray(parsedLight.specular);
-
-        if (parsedLight.excludedMeshesIds) {
-            light._excludedMeshesIds = parsedLight.excludedMeshesIds;
-        }
-
-        // Parent
-        if (parsedLight.parentId) {
-            light._waitingParentId = parsedLight.parentId;
-        }
-
-        if (parsedLight.includedOnlyMeshesIds) {
-            light._includedOnlyMeshesIds = parsedLight.includedOnlyMeshesIds;
-        }
-
-        // Animations
-        if (parsedLight.animations) {
-            for (var animationIndex = 0; animationIndex < parsedLight.animations.length; animationIndex++) {
-                var parsedAnimation = parsedLight.animations[animationIndex];
-
-                light.animations.push(Animation.ParseAnimation(parsedAnimation));
-            }
-        }
-
-        if (parsedLight.autoAnimate) {
-            scene.beginAnimation(light, parsedLight.autoAnimateFrom, parsedLight.autoAnimateTo, parsedLight.autoAnimateLoop, 1.0);
-        }
-    };
-
-    var parseCamera = (parsedCamera, scene: Scene) => {
-        var camera;
-        var position = Vector3.FromArray(parsedCamera.position);
-        var lockedTargetMesh = (parsedCamera.lockedTargetId) ? scene.getLastMeshByID(parsedCamera.lockedTargetId) : null;
-
-        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;
-                camera = new AnaglyphArcRotateCamera(parsedCamera.name, alpha, beta, radius, lockedTargetMesh, interaxial_distance, scene);
-            } else {
-                camera = new ArcRotateCamera(parsedCamera.name, alpha, beta, radius, lockedTargetMesh, scene);
-            }
-
-        } else if (parsedCamera.type === "AnaglyphFreeCamera") {
-            interaxial_distance = parsedCamera.interaxial_distance;
-            camera = new AnaglyphFreeCamera(parsedCamera.name, position, interaxial_distance, scene);
-
-        } else if (parsedCamera.type === "DeviceOrientationCamera") {
-            camera = new DeviceOrientationCamera(parsedCamera.name, position, scene);
-
-        } else if (parsedCamera.type === "FollowCamera") {
-            camera = new FollowCamera(parsedCamera.name, position, scene);
-            camera.heightOffset = parsedCamera.heightOffset;
-            camera.radius = parsedCamera.radius;
-            camera.rotationOffset = parsedCamera.rotationOffset;
-            if (lockedTargetMesh)
-                (<FollowCamera>camera).target = lockedTargetMesh;
-
-        } else if (parsedCamera.type === "GamepadCamera") {
-            camera = new GamepadCamera(parsedCamera.name, position, scene);
-
-        } else if (parsedCamera.type === "TouchCamera") {
-            camera = new TouchCamera(parsedCamera.name, position, scene);
-
-        } else if (parsedCamera.type === "VirtualJoysticksCamera") {
-            camera = new VirtualJoysticksCamera(parsedCamera.name, position, scene);
-
-        } else if (parsedCamera.type === "WebVRFreeCamera") {
-            camera = new WebVRFreeCamera(parsedCamera.name, position, scene);
-
-        } else if (parsedCamera.type === "VRDeviceOrientationFreeCamera") {
-            camera = new VRDeviceOrientationFreeCamera(parsedCamera.name, position, scene);
-
-        } else {
-            // Free Camera is the default value
-            camera = new FreeCamera(parsedCamera.name, position, scene);
-        }
-
-        // apply 3d rig, when found
-        if (parsedCamera.cameraRigMode) {
-            var rigParams = (parsedCamera.interaxial_distance) ? { interaxialDistance: parsedCamera.interaxial_distance } : {};
-            camera.setCameraRigMode(parsedCamera.cameraRigMode, rigParams);
-        }
-
-        // Test for lockedTargetMesh & FreeCamera outside of if-else-if nest, since things like GamepadCamera extend FreeCamera
-        if (lockedTargetMesh && camera instanceof FreeCamera) {
-            (<FreeCamera>camera).lockedTarget = lockedTargetMesh;
-        }
-
-        camera.id = parsedCamera.id;
-
-        BABYLON.Tags.AddTagsTo(camera, parsedCamera.tags);
-
-        // Parent
-        if (parsedCamera.parentId) {
-            camera._waitingParentId = parsedCamera.parentId;
-        }
-
-        // Target
-        if (parsedCamera.target) {
-            if (camera.setTarget) {
-                camera.setTarget(BABYLON.Vector3.FromArray(parsedCamera.target));
-            } else {
-                //For ArcRotate
-                camera.target = BABYLON.Vector3.FromArray(parsedCamera.target);
-            }
-        } else {
-            camera.rotation = BABYLON.Vector3.FromArray(parsedCamera.rotation);
-        }
-
-        camera.fov = parsedCamera.fov;
-        camera.minZ = parsedCamera.minZ;
-        camera.maxZ = parsedCamera.maxZ;
-
-        camera.speed = parsedCamera.speed;
-        camera.inertia = parsedCamera.inertia;
-
-        camera.checkCollisions = parsedCamera.checkCollisions;
-        camera.applyGravity = parsedCamera.applyGravity;
-        if (parsedCamera.ellipsoid) {
-            camera.ellipsoid = BABYLON.Vector3.FromArray(parsedCamera.ellipsoid);
-        }
-
-        // Animations
-        if (parsedCamera.animations) {
-            for (var animationIndex = 0; animationIndex < parsedCamera.animations.length; animationIndex++) {
-                var parsedAnimation = parsedCamera.animations[animationIndex];
-
-                camera.animations.push(Animation.ParseAnimation(parsedAnimation));
-            }
-        }
-
-        if (parsedCamera.autoAnimate) {
-            scene.beginAnimation(camera, parsedCamera.autoAnimateFrom, parsedCamera.autoAnimateTo, parsedCamera.autoAnimateLoop, 1.0);
-        }
-
-        // Layer Mask
-        if (parsedCamera.layerMask && (!isNaN(parsedCamera.layerMask))) {
-            camera.layerMask = Math.abs(parseInt(parsedCamera.layerMask));
-        } else {
-            camera.layerMask = 0x0FFFFFFF;
-        }
-
-        return camera;
-    };
-
     var parseGeometry = (parsedGeometry, scene) => {
         var id = parsedGeometry.id;
         return scene.getGeometryByID(id);
@@ -1292,7 +978,7 @@
                                     }
 
                                     loadedMaterialsIds.push(parsedMultiMaterial.id);
-                                    parseMultiMaterial(parsedMultiMaterial, scene);
+                                    parsedMultiMaterial.ParseMultiMaterial(parsedMultiMaterial, scene);
                                     materialFound = true;
                                     break;
                                 }
@@ -1316,7 +1002,7 @@
                                 var parsedSkeleton = parsedData.skeletons[skeletonIndex];
 
                                 if (parsedSkeleton.id === parsedMesh.skeletonId) {
-                                    skeletons.push(parseSkeleton(parsedSkeleton, scene));
+                                    skeletons.push(Skeleton.ParseSkeleton(parsedSkeleton, scene));
                                     loadedSkeletonsIds.push(parsedSkeleton.id);
                                 }
                             }
@@ -1353,7 +1039,7 @@
                     var parsedParticleSystem = parsedData.particleSystems[index];
 
                     if (hierarchyIds.indexOf(parsedParticleSystem.emitterId) !== -1) {
-                        particleSystems.push(parseParticleSystem(parsedParticleSystem, scene, rootUrl));
+                        particleSystems.push(ParticleSystem.ParseParticleSystem(parsedParticleSystem, scene, rootUrl));
                     }
                 }
             }
@@ -1404,21 +1090,21 @@
             var index: number;
             for (index = 0; index < parsedData.lights.length; index++) {
                 var parsedLight = parsedData.lights[index];
-                parseLight(parsedLight, scene);
+                Light.ParseLight(parsedLight, scene);
             }
 
             // Materials
             if (parsedData.materials) {
                 for (index = 0; index < parsedData.materials.length; index++) {
                     var parsedMaterial = parsedData.materials[index];
-                    parseMaterial(parsedMaterial, scene, rootUrl);
+                    Material.ParseMaterial(parsedMaterial, scene, rootUrl);
                 }
             }
 
             if (parsedData.multiMaterials) {
                 for (index = 0; index < parsedData.multiMaterials.length; index++) {
                     var parsedMultiMaterial = parsedData.multiMaterials[index];
-                    parseMultiMaterial(parsedMultiMaterial, scene);
+                    MultiMaterial.ParseMultiMaterial(parsedMultiMaterial, scene);
                 }
             }
 
@@ -1426,7 +1112,7 @@
             if (parsedData.skeletons) {
                 for (index = 0; index < parsedData.skeletons.length; index++) {
                     var parsedSkeleton = parsedData.skeletons[index];
-                    parseSkeleton(parsedSkeleton, scene);
+                    Skeleton.ParseSkeleton(parsedSkeleton, scene);
                 }
             }
 
@@ -1515,7 +1201,7 @@
             // Cameras
             for (index = 0; index < parsedData.cameras.length; index++) {
                 var parsedCamera = parsedData.cameras[index];
-                parseCamera(parsedCamera, scene);
+                Camera.ParseCamera(parsedCamera, scene);
             }
 
             if (parsedData.activeCameraID) {
@@ -1578,7 +1264,7 @@
             if (parsedData.particleSystems) {
                 for (index = 0; index < parsedData.particleSystems.length; index++) {
                     var parsedParticleSystem = parsedData.particleSystems[index];
-                    parseParticleSystem(parsedParticleSystem, scene, rootUrl);
+                    ParticleSystem.ParseParticleSystem(parsedParticleSystem, scene, rootUrl);
                 }
             }
 
@@ -1586,7 +1272,7 @@
             if (parsedData.lensFlareSystems) {
                 for (index = 0; index < parsedData.lensFlareSystems.length; index++) {
                     var parsedLensFlareSystem = parsedData.lensFlareSystems[index];
-                    parseLensFlareSystem(parsedLensFlareSystem, scene, rootUrl);
+                    LensFlareSystem.ParseLensFlareSystem(parsedLensFlareSystem, scene, rootUrl);
                 }
             }
 
@@ -1595,7 +1281,7 @@
                 for (index = 0; index < parsedData.shadowGenerators.length; index++) {
                     var parsedShadowGenerator = parsedData.shadowGenerators[index];
 
-                    parseShadowGenerator(parsedShadowGenerator, scene);
+                    ShadowGenerator.ParseShadowGenerator(parsedShadowGenerator, scene);
                 }
             }
 

src/Materials/Textures/babylon.baseTexture.js

@@ -114,66 +114,6 @@ var BABYLON;
                 this.onDispose();
             }
         };
-        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.cubeTexture.js

@@ -57,6 +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;
+            }
+            return texture;
+        };
         return CubeTexture;
     })(BABYLON.BaseTexture);
     BABYLON.CubeTexture = CubeTexture;

src/Materials/Textures/babylon.texture.js

@@ -187,6 +187,55 @@ var BABYLON;
             if (onError === void 0) { onError = null; }
             return new Texture("data:" + name, scene, noMipmap, invertY, samplingMode, onLoad, onError, data);
         };
+        Texture.ParseTexture = function (parsedTexture, scene, rootUrl) {
+            if (parsedTexture.isCube) {
+                return BABYLON.CubeTexture.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 = 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(BABYLON.Animation.ParseAnimation(parsedAnimation));
+                }
+            }
+            return texture;
+        };
         // Constants
         Texture.NEAREST_SAMPLINGMODE = 1;
         Texture.BILINEAR_SAMPLINGMODE = 2;

src/Materials/babylon.material.js

@@ -232,6 +232,13 @@ 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._TriangleFillMode = 0;
         Material._WireFrameFillMode = 1;
         Material._PointFillMode = 2;

src/Materials/babylon.multiMaterial.js

@@ -39,6 +39,21 @@ var BABYLON;
             }
             return newMultiMaterial;
         };
+        MultiMaterial.ParseMultiMaterial = function (parsedMultiMaterial, scene) {
+            var multiMaterial = new BABYLON.MultiMaterial(parsedMultiMaterial.name, scene);
+            multiMaterial.id = parsedMultiMaterial.id;
+            BABYLON.Tags.AddTagsTo(multiMaterial, parsedMultiMaterial.tags);
+            for (var matIndex = 0; matIndex < parsedMultiMaterial.materials.length; matIndex++) {
+                var subMatId = parsedMultiMaterial.materials[matIndex];
+                if (subMatId) {
+                    multiMaterial.subMaterials.push(scene.getMaterialByID(subMatId));
+                }
+                else {
+                    multiMaterial.subMaterials.push(null);
+                }
+            }
+            return multiMaterial;
+        };
         return MultiMaterial;
     })(BABYLON.Material);
     BABYLON.MultiMaterial = MultiMaterial;

src/Materials/babylon.standardMaterial.js

@@ -895,41 +895,41 @@ var BABYLON;
             material.backFaceCulling = source.backFaceCulling;
             material.wireframe = source.wireframe;
             if (source.diffuseTexture) {
-                material.diffuseTexture = BABYLON.BaseTexture.ParseTexture(source.diffuseTexture, scene, rootUrl);
+                material.diffuseTexture = BABYLON.Texture.ParseTexture(source.diffuseTexture, scene, rootUrl);
             }
             if (source.diffuseFresnelParameters) {
                 material.diffuseFresnelParameters = StandardMaterial.ParseFresnelParameters(source.diffuseFresnelParameters);
             }
             if (source.ambientTexture) {
-                material.ambientTexture = BABYLON.BaseTexture.ParseTexture(source.ambientTexture, scene, rootUrl);
+                material.ambientTexture = BABYLON.Texture.ParseTexture(source.ambientTexture, scene, rootUrl);
             }
             if (source.opacityTexture) {
-                material.opacityTexture = BABYLON.BaseTexture.ParseTexture(source.opacityTexture, scene, rootUrl);
+                material.opacityTexture = BABYLON.Texture.ParseTexture(source.opacityTexture, scene, rootUrl);
             }
             if (source.opacityFresnelParameters) {
                 material.opacityFresnelParameters = StandardMaterial.ParseFresnelParameters(source.opacityFresnelParameters);
             }
             if (source.reflectionTexture) {
-                material.reflectionTexture = BABYLON.BaseTexture.ParseTexture(source.reflectionTexture, scene, rootUrl);
+                material.reflectionTexture = BABYLON.Texture.ParseTexture(source.reflectionTexture, scene, rootUrl);
             }
             if (source.reflectionFresnelParameters) {
                 material.reflectionFresnelParameters = StandardMaterial.ParseFresnelParameters(source.reflectionFresnelParameters);
             }
             if (source.emissiveTexture) {
-                material.emissiveTexture = BABYLON.BaseTexture.ParseTexture(source.emissiveTexture, scene, rootUrl);
+                material.emissiveTexture = BABYLON.Texture.ParseTexture(source.emissiveTexture, scene, rootUrl);
             }
             if (source.lightmapTexture) {
-                material.lightmapTexture = BABYLON.BaseTexture.ParseTexture(source.lightmapTexture, scene, rootUrl);
+                material.lightmapTexture = BABYLON.Texture.ParseTexture(source.lightmapTexture, scene, rootUrl);
                 material.useLightmapAsShadowmap = source.useLightmapAsShadowmap;
             }
             if (source.emissiveFresnelParameters) {
                 material.emissiveFresnelParameters = StandardMaterial.ParseFresnelParameters(source.emissiveFresnelParameters);
             }
             if (source.specularTexture) {
-                material.specularTexture = BABYLON.BaseTexture.ParseTexture(source.specularTexture, scene, rootUrl);
+                material.specularTexture = BABYLON.Texture.ParseTexture(source.specularTexture, scene, rootUrl);
             }
             if (source.bumpTexture) {
-                material.bumpTexture = BABYLON.BaseTexture.ParseTexture(source.bumpTexture, scene, rootUrl);
+                material.bumpTexture = BABYLON.Texture.ParseTexture(source.bumpTexture, scene, rootUrl);
             }
             if (source.checkReadyOnlyOnce) {
                 material.checkReadyOnlyOnce = source.checkReadyOnlyOnce;

src/Materials/babylon.standardMaterial.ts

@@ -1093,7 +1093,7 @@
             material.wireframe = source.wireframe;
 
             if (source.diffuseTexture) {
-                material.diffuseTexture = BaseTexture.ParseTexture(source.diffuseTexture, scene, rootUrl);
+                material.diffuseTexture = Texture.ParseTexture(source.diffuseTexture, scene, rootUrl);
             }
 
             if (source.diffuseFresnelParameters) {
@@ -1101,11 +1101,11 @@
             }
 
             if (source.ambientTexture) {
-                material.ambientTexture = BaseTexture.ParseTexture(source.ambientTexture, scene, rootUrl);
+                material.ambientTexture = Texture.ParseTexture(source.ambientTexture, scene, rootUrl);
             }
 
             if (source.opacityTexture) {
-                material.opacityTexture = BaseTexture.ParseTexture(source.opacityTexture, scene, rootUrl);
+                material.opacityTexture = Texture.ParseTexture(source.opacityTexture, scene, rootUrl);
             }
 
             if (source.opacityFresnelParameters) {
@@ -1113,7 +1113,7 @@
             }
 
             if (source.reflectionTexture) {
-                material.reflectionTexture = BaseTexture.ParseTexture(source.reflectionTexture, scene, rootUrl);
+                material.reflectionTexture = Texture.ParseTexture(source.reflectionTexture, scene, rootUrl);
             }
 
             if (source.reflectionFresnelParameters) {
@@ -1121,11 +1121,11 @@
             }
 
             if (source.emissiveTexture) {
-                material.emissiveTexture = BaseTexture.ParseTexture(source.emissiveTexture, scene, rootUrl);
+                material.emissiveTexture = Texture.ParseTexture(source.emissiveTexture, scene, rootUrl);
             }
 
             if (source.lightmapTexture) {
-                material.lightmapTexture = BaseTexture.ParseTexture(source.lightmapTexture, scene, rootUrl);
+                material.lightmapTexture = Texture.ParseTexture(source.lightmapTexture, scene, rootUrl);
                 material.useLightmapAsShadowmap = source.useLightmapAsShadowmap;
             }
 
@@ -1134,11 +1134,11 @@
             }
 
             if (source.specularTexture) {
-                material.specularTexture = BaseTexture.ParseTexture(source.specularTexture, scene, rootUrl);
+                material.specularTexture = Texture.ParseTexture(source.specularTexture, scene, rootUrl);
             }
 
             if (source.bumpTexture) {
-                material.bumpTexture = BaseTexture.ParseTexture(source.bumpTexture, scene, rootUrl);
+                material.bumpTexture = Texture.ParseTexture(source.bumpTexture, scene, rootUrl);
             }
 
             if (source.checkReadyOnlyOnce) {

src/Particles/babylon.particleSystem.js

@@ -328,6 +328,36 @@ var BABYLON;
             result.start();
             return result;
         };
+        ParticleSystem.ParseParticleSystem = function (parsedParticleSystem, scene, rootUrl) {
+            var emitter = scene.getLastMeshByID(parsedParticleSystem.emitterId);
+            var particleSystem = new ParticleSystem("particles#" + emitter.name, parsedParticleSystem.capacity, scene);
+            if (parsedParticleSystem.textureName) {
+                particleSystem.particleTexture = new BABYLON.Texture(rootUrl + parsedParticleSystem.textureName, scene);
+                particleSystem.particleTexture.name = parsedParticleSystem.textureName;
+            }
+            particleSystem.minAngularSpeed = parsedParticleSystem.minAngularSpeed;
+            particleSystem.maxAngularSpeed = parsedParticleSystem.maxAngularSpeed;
+            particleSystem.minSize = parsedParticleSystem.minSize;
+            particleSystem.maxSize = parsedParticleSystem.maxSize;
+            particleSystem.minLifeTime = parsedParticleSystem.minLifeTime;
+            particleSystem.maxLifeTime = parsedParticleSystem.maxLifeTime;
+            particleSystem.emitter = emitter;
+            particleSystem.emitRate = parsedParticleSystem.emitRate;
+            particleSystem.minEmitBox = BABYLON.Vector3.FromArray(parsedParticleSystem.minEmitBox);
+            particleSystem.maxEmitBox = BABYLON.Vector3.FromArray(parsedParticleSystem.maxEmitBox);
+            particleSystem.gravity = BABYLON.Vector3.FromArray(parsedParticleSystem.gravity);
+            particleSystem.direction1 = BABYLON.Vector3.FromArray(parsedParticleSystem.direction1);
+            particleSystem.direction2 = BABYLON.Vector3.FromArray(parsedParticleSystem.direction2);
+            particleSystem.color1 = BABYLON.Color4.FromArray(parsedParticleSystem.color1);
+            particleSystem.color2 = BABYLON.Color4.FromArray(parsedParticleSystem.color2);
+            particleSystem.colorDead = BABYLON.Color4.FromArray(parsedParticleSystem.colorDead);
+            particleSystem.updateSpeed = parsedParticleSystem.updateSpeed;
+            particleSystem.targetStopDuration = parsedParticleSystem.targetStopFrame;
+            particleSystem.textureMask = BABYLON.Color4.FromArray(parsedParticleSystem.textureMask);
+            particleSystem.blendMode = parsedParticleSystem.blendMode;
+            particleSystem.start();
+            return particleSystem;
+        };
         // Statics
         ParticleSystem.BLENDMODE_ONEONE = 0;
         ParticleSystem.BLENDMODE_STANDARD = 1;