move SceneAssetContainer to a new file and remove config data

src/Loading/babylon.sceneLoader.ts

@@ -37,6 +37,7 @@
         loadAsync: (scene: Scene, data: string, rootUrl: string, onSuccess?: () => void, onProgress?: (event: SceneLoaderProgressEvent) => void, onError?: (message: string, exception?: any) => void) => void;
         canDirectLoad?: (data: string) => boolean;
         rewriteRootURL?: (rootUrl: string, responseURL?: string) => string;
+        loadAssetsAsync: (scene: Scene, data: string, rootUrl: string, onSuccess?: (assets: SceneAssetContainer) => void, onProgress?: (event: SceneLoaderProgressEvent) => void, onError?: (message: string, exception?: any) => void) => void;
     }
 
     interface IRegisteredPlugin {
@@ -456,5 +457,86 @@
                 }
             }, progressHandler, errorHandler, disposeHandler, pluginExtension);
         }
+        
+        public static LoadAssetContainer(
+            rootUrl: string,
+            sceneFilename: any,
+            scene: Scene,
+            onSuccess: Nullable<(assets: SceneAssetContainer) => void> = null,
+            onProgress: Nullable<(event: SceneLoaderProgressEvent) => void> = null,
+            onError: Nullable<(scene: Scene, message: string, exception?: any) => void> = null,
+            pluginExtension: Nullable<string> = null
+        ): Nullable<ISceneLoaderPlugin | ISceneLoaderPluginAsync> {
+            if (sceneFilename.substr && sceneFilename.substr(0, 1) === "/") {
+                Tools.Error("Wrong sceneFilename parameter");
+                return null;
+            }
+
+            var loadingToken = {};
+            scene._addPendingData(loadingToken);
+
+            var disposeHandler = () => {
+                scene._removePendingData(loadingToken);
+            };
+
+            var errorHandler = (message: Nullable<string>, exception?: any) => {
+                let errorMessage = "Unable to load assets from " + rootUrl + sceneFilename + (message ? ": " + message : "");
+                if (onError) {
+                    onError(scene, errorMessage, exception);
+                } else {
+                    Tools.Error(errorMessage);
+                    // should the exception be thrown?
+                }
+
+                disposeHandler();
+            };
+
+            var progressHandler = onProgress ? (event: SceneLoaderProgressEvent) => {
+                try {
+                    onProgress(event);
+                }
+                catch (e) {
+                    errorHandler("Error in onProgress callback", e);
+                }
+            } : undefined;
+
+            var successHandler = (assets: SceneAssetContainer) => {
+                if (onSuccess) {
+                    try {
+                        onSuccess(assets);
+                    }
+                    catch (e) {
+                        errorHandler("Error in onSuccess callback", e);
+                    }
+                }
+
+                scene._removePendingData(loadingToken);
+            };
+
+            return SceneLoader._loadData(rootUrl, sceneFilename, scene, (plugin, data, responseURL) => {
+                if ((<any>plugin).loadAssets) {
+                    var syncedPlugin = <ISceneLoaderPlugin>plugin;
+                    var assetContainer = syncedPlugin.loadAssets(scene, data, rootUrl, errorHandler);
+                    if (!assetContainer) {
+                        return;
+                    }
+
+                    scene.loadingPluginName = plugin.name;
+                    successHandler(assetContainer);
+                } else {
+                    var asyncedPlugin = <ISceneLoaderPluginAsync>plugin;
+                    asyncedPlugin.loadAssetsAsync(scene, data, rootUrl, (assetContainer) => {
+                        scene.loadingPluginName = plugin.name;
+                        successHandler(assetContainer);
+                    }, progressHandler, errorHandler);
+                }
+
+                if (SceneLoader.ShowLoadingScreen) {
+                    scene.executeWhenReady(() => {
+                        scene.getEngine().hideLoadingUI();
+                    });
+                }
+            }, progressHandler, errorHandler, disposeHandler, pluginExtension);
+        }
     };
 }

src/babylon.assetContainer.ts

@@ -0,0 +1,32 @@
+module BABYLON {
+    export class SceneAssetContainer {
+        public scene: Scene;
+
+        // Objects
+        public cameras = new Array<Camera>();
+        public lights = new Array<Light>();
+        public meshes = new Array<AbstractMesh>();
+        public skeletons = new Array<Skeleton>();
+        public particleSystems = new Array<ParticleSystem>();
+        public animations = new Array<Animation>();
+        public multiMaterials = new Array<MultiMaterial>();
+        public materials = new Array<Material>();
+        public morphTargetManagers = new Array<MorphTargetManager>();
+        public geometries = new Array<Geometry>();
+        public transformNodes = new Array<TransformNode>();
+        public lensFlareSystems = new Array<LensFlareSystem>();
+        public shadowGenerators = new Array<ShadowGenerator>();
+        public actionManagers = new Array<ActionManager>();
+        
+        constructor(scene:Scene){
+            this.scene = scene;
+        }
+        
+        addAllToScene(){
+            // TODO
+        }
+        removeAllFromScene(){
+            // TODO
+        }
+    }
+}

src/babylon.scene.ts

@@ -3,72 +3,6 @@
         dispose(): void;
     }
 
-    export class SceneAssetContainer {
-            public scene: Scene;
-
-            // Config
-            public useDelayedTextureLoading:boolean;
-            public autoClear:boolean;
-            public clearColor:Color4;
-            public ambientColor:Color3;
-            public metadata:any;
-            public activeCameraID:string;
-
-            // Physics
-            public gravity:Vector3;
-            public physicsGravity:Nullable<Vector3>;
-            public physicsPluginName:string;
-            public enablePhysics: boolean;
-            public collisionsEnabled:boolean;
-            public workerCollisions:boolean;
-
-            // Fog
-            public fogMode:number;
-            public fogColor:Color3;
-            public fogStart:number;
-            public fogEnd:number;
-            public fogDensity:number;
-
-            // Animation
-            public autoAnimate:boolean;
-            public autoAnimateFrom:number;
-            public autoAnimateTo:number;
-            public autoAnimateLoop:number;
-            public autoAnimateSpeed:number;
-
-            // Skybox
-            public createDefaultSkybox:boolean;
-            public environmentTexture:BaseTexture;
-            public skyboxBlurLevel:number;
-
-            // Objects
-            public cameras = new Array<Camera>();
-            public lights = new Array<Light>();
-            public meshes = new Array<AbstractMesh>();
-            public skeletons = new Array<Skeleton>();
-            public particleSystems = new Array<ParticleSystem>();
-            public animations = new Array<Animation>();
-            public multiMaterials = new Array<MultiMaterial>();
-            public materials = new Array<Material>();
-            public morphTargetManagers = new Array<MorphTargetManager>();
-            public geometries = new Array<Geometry>();
-            public transformNodes = new Array<TransformNode>();
-            public lensFlareSystems = new Array<LensFlareSystem>();
-            public shadowGenerators = new Array<ShadowGenerator>();
-            public actionManagers = new Array<ActionManager>();
-            
-            constructor(scene:Scene){
-                this.scene = scene;
-            }
-            
-            addAllToScene(){
-                // TODO
-            }
-            removeAllFromScene(){
-                // TODO
-            }
-        }
-
     export interface IActiveMeshCandidateProvider {
         getMeshes(scene: Scene): AbstractMesh[];
         readonly checksIsEnabled: boolean; // Indicates if the meshes have been checked to make sure they are isEnabled().