initModel will initialize a model

Viewer/dist/basicExample.html

@@ -28,22 +28,7 @@
             // a simple way of disabling auto init 
             BabylonViewer.disableInit = true;
             // Initializing the viewer on specific HTML tags.
-            //BabylonViewer.InitTags('babylon');
-            var state = 0;
-            window.onclick = function () {
-                if (state === 0) {
-                    console.log("loading");
-                    BabylonViewer.InitTags('babylon');
-                    state++;
-                } else if (state === 1) {
-                    /*BabylonViewer.viewerManager.getViewerPromiseById('babylon-viewer').then(function (viewer) {
-                        viewer.dispose();
-                        console.log("disposed");
-                    });*/
-                    BabylonViewer.disposeAll();
-                }
-
-            }
+            BabylonViewer.InitTags('babylon');
         </script>
     </body>
 

Viewer/src/model/viewerModel.ts

@@ -68,7 +68,7 @@ export class ViewerModel implements IDisposable {
     }
 
     public get configuration(): IModelConfiguration {
-        return this.configuration;
+        return this._modelConfiguration;
     }
 
     public set configuration(newConfiguration: IModelConfiguration) {

Viewer/src/viewer/defaultViewer.ts

@@ -104,12 +104,12 @@ export class DefaultViewer extends AbstractViewer {
         this.containerElement.style.display = 'flex';
     }
 
-    protected configureModel(modelConfiguration: Partial<IModelConfiguration>, model: ViewerModel) {
-        super.configureModel(modelConfiguration, model);
-
+    protected configureTemplate(model: ViewerModel) {
         let navbar = this.templateManager.getTemplate('navBar');
         if (!navbar) return;
 
+        let modelConfiguration = model.configuration;
+
         let metadataContainer = navbar.parent.querySelector('#model-metadata');
         if (metadataContainer) {
             if (modelConfiguration.title !== undefined) {
@@ -143,6 +143,7 @@ export class DefaultViewer extends AbstractViewer {
     }
 
     private onModelLoaded = (model: ViewerModel) => {
+        this.configureTemplate(model);
         // with a short timeout, making sure everything is there already.
         let hideLoadingDelay = 500;
         if (this.configuration.lab && this.configuration.lab.hideLoadingDelay !== undefined) {

Viewer/src/viewer/viewer.ts

@@ -696,6 +696,43 @@ export abstract class AbstractViewer {
     private isLoading: boolean;
     private nextLoading: Function;
 
+    public initModel(modelConfig: any = this.configuration.model, clearScene: boolean = true): ViewerModel {
+        let model = this.modelLoader.load(modelConfig);
+
+        if (clearScene) {
+            this.models.forEach(m => m.dispose());
+            this.models.length = 0;
+        }
+
+        this.models.push(model);
+        this.lastUsedLoader = model.loader;
+        model.onLoadErrorObservable.add((errorObject) => {
+            this.onModelLoadErrorObservable.notifyObserversWithPromise(errorObject);
+        });
+        model.onLoadProgressObservable.add((progressEvent) => {
+            return this.onModelLoadProgressObservable.notifyObserversWithPromise(progressEvent);
+        });
+        this.onLoaderInitObservable.notifyObserversWithPromise(this.lastUsedLoader);
+
+        model.onLoadedObservable.add(() => {
+            this.onModelLoadedObservable.notifyObserversWithPromise(model)
+                .then(() => {
+                    this.configureLights(this.configuration.lights);
+
+                    if (this.configuration.camera) {
+                        this.configureCamera(this.configuration.camera, model);
+                    }
+                    return this.initEnvironment(model);
+                }).then(() => {
+                    this.isLoading = false;
+                    return model;
+                });
+        });
+
+
+        return model;
+    }
+
     public loadModel(modelConfig: any = this.configuration.model, clearScene: boolean = true): Promise<ViewerModel> {
         // no model was provided? Do nothing!
         let modelUrl = (typeof modelConfig === 'string') ? modelConfig : modelConfig.url;
@@ -721,45 +758,13 @@ export abstract class AbstractViewer {
 
         return Promise.resolve(this.scene).then((scene) => {
             if (!scene) return this.initScene();
-
-            if (clearScene) {
-                this.models.forEach(m => m.dispose());
-                this.models.length = 0;
-            }
             return scene;
         }).then(() => {
             return new Promise<ViewerModel>((resolve, reject) => {
                 // at this point, configuration.model is an object, not a string
-                let model = this.modelLoader.load(<IModelConfiguration>this.configuration.model);
-                this.models.push(model);
-                this.lastUsedLoader = model.loader;
-                model.onLoadedObservable.add((model) => {
-                    resolve(model);
-                });
-                model.onLoadErrorObservable.add((errorObject) => {
-                    this.onModelLoadErrorObservable.notifyObserversWithPromise(errorObject).then(() => {
-                        reject(errorObject.exception);
-                    });
-                });
-                model.onLoadProgressObservable.add((progressEvent) => {
-                    return this.onModelLoadProgressObservable.notifyObserversWithPromise(progressEvent);
-                });
-                this.onLoaderInitObservable.notifyObserversWithPromise(this.lastUsedLoader);
+                return this.initModel(modelConfig, clearScene);
             });
-        }).then((model: ViewerModel) => {
-            return this.onModelLoadedObservable.notifyObserversWithPromise(model)
-                .then(() => {
-                    this.configureLights(this.configuration.lights);
-
-                    if (this.configuration.camera) {
-                        this.configureCamera(this.configuration.camera, model);
-                    }
-                    return this.initEnvironment(model);
-                }).then(() => {
-                    this.isLoading = false;
-                    return model;
-                });
-        });
+        })
     }
 
     protected initEnvironment(model?: ViewerModel): Promise<Scene> {

dist/preview release/viewer/babylon.viewer.d.ts

@@ -520,6 +520,7 @@ declare module BabylonViewer {
         protected onTemplatesLoaded(): Promise<AbstractViewer>;
         protected initEngine(): Promise<BABYLON.Engine>;
         protected initScene(): Promise<BABYLON.Scene>;
+        initModel(modelConfig?: any, clearScene?: boolean): ViewerModel
         loadModel(modelConfig?: any, clearScene?: boolean): Promise<ViewerModel>;
         public addModel(meshes: Array<AbstractMesh>, skeletons: Array<Skeleton>, particleSystems: Array<ParticleSystem>, animationGroups: Array<AnimationGroup>): ViewerModel;
         protected initEnvironment(viewerModel?: ViewerModel): Promise<BABYLON.Scene>;