public load() {
     if (this.loader) {
         Tools.Error("Model was already loaded or in the process of loading.");
     } else {
         this._initLoad();
     }
 }

    private _initLoad() {
        if (!this._modelConfiguration || !this._modelConfiguration.url) {
            return Tools.Error("No model URL to load.");
        }
        let parts = this._modelConfiguration.url.split('/');
        let filename = parts.pop() || this._modelConfiguration.url;
        let base = parts.length ? parts.join('/') + '/' : './';

        let plugin = this._modelConfiguration.loader;

        //temp solution for animation group handling
        let animationsArray = this._scene.animationGroups.slice();

        this.loader = SceneLoader.ImportMesh(undefined, base, filename, this._scene, (meshes, particleSystems, skeletons) => {
            meshes.forEach(mesh => {
                Tags.AddTagsTo(mesh, "viewerMesh");
            });
            this.meshes = meshes;
            this.particleSystems = particleSystems;
            this.skeletons = skeletons;

            // check if this is a gltf loader and load the animations
            if (this.loader.name === 'gltf') {
                this._scene.animationGroups.forEach(ag => {
                    // add animations that didn't exist before
                    if (animationsArray.indexOf(ag) === -1) {
                        this._animations.push(new GroupModelAnimation(ag));
                    }
                })
            } else {
                skeletons.forEach((skeleton, idx) => {
                    let ag = new BABYLON.AnimationGroup("animation-" + idx, this._scene);
                    skeleton.getAnimatables().forEach(a => {
                        if (a.animations[0]) {
                            ag.addTargetedAnimation(a.animations[0], a);
                        }
                    });
                    this._animations.push(new GroupModelAnimation(ag));
                });
            }

            if (this._modelConfiguration.animation) {
                if (this._modelConfiguration.animation.playOnce) {
                    this._animations.forEach(a => {
                        a.playMode = AnimationPlayMode.ONCE;
                    });
                }
                if (this._modelConfiguration.animation.autoStart && this._animations.length) {
                    let animationName = this._modelConfiguration.animation.autoStart === true ?
                        this._animations[0].name : this._modelConfiguration.animation.autoStart;
                    this.playAnimation(animationName);
                }
            }

            this.onLoadedObservable.notifyObserversWithPromise(this);
        }, (progressEvent) => {
            this.onLoadProgressObservable.notifyObserversWithPromise(progressEvent);
        }, (e, m, exception) => {
            this.onLoadErrorObservable.notifyObserversWithPromise({ message: m, exception: exception });
        }, plugin)!;

        this.loader['animationStartMode'] = 0;
    }

         b: 0.8823529411764706
     }
 },
 loaderPlugins: {
     extendedMaterial: true,
     applyMaterialConfig: true,
     msftLod: true,
     telemetry: true
 },
 model: {
     rotationOffsetAxis: {
         x: 0,
         y: -1,
         z: 0
     },
     rotationOffsetAngle: Tools.ToRadians(210),
     material: {
         directEnabled: true,
         directIntensity: 0.884,
         emissiveIntensity: 1.04,
         environmentIntensity: 0.6
     },
     entryAnimation: {
         scaling: {
             x: 0,
             y: 0,
             z: 0
         },
         time: 0.5,
         easingFunction: 4,
         easingMode: 1

 return new Promise<Blob>((resolve) => {
     BabylonTools.ToBlob(canvas, b => resolve(b));
 });

export function addLoaderPlugin(name: string, plugin: ILoaderPlugin) {
    if (pluginCache[name]) {
        Tools.Warn("Overwriting plugin with the same name - " + name);
    }
    pluginCache[name] = plugin;
}

 return new Promise((resolve, reject) => {
     let fileRequest = Tools.LoadFile(url, resolve, undefined, undefined, false, (request, error: any) => {
         reject(error);
     });
     this.loadRequests.push(fileRequest);
 });