TypeScript babylonjs.Observable類代碼示例

    /**
     * dispose the manager and all of its associated viewers
     */
    public dispose() {
        delete this._onViewerAdded;

        for (let id in this._viewers) {
            this._viewers[id].dispose();
        }

        this.onViewerAddedObservable.clear();
        this.onViewerRemovedObservable.clear();
    }

 dispose() {
     this.onSceneInitObservable.clear();
     this.onEngineInitObservable.clear();
     this.onModelLoadedObservable.clear();
     this.onModelLoadProgressObservable.clear();
     this.onModelLoadErrorObservable.clear();
     this.onModelAddedObservable.clear();
     this.onModelRemovedObservable.clear();
     this.onViewerInitDoneObservable.clear();
     this.onLoaderInitObservable.clear();
     this.onFrameRenderedObservable.clear();
 }

 return new Promise((resolve, reject) => {
     let localViewer = this.getViewerById(id)
     if (localViewer) {
         return resolve(localViewer);
     }
     let viewerFunction = (viewer: AbstractViewer) => {
         if (viewer.getBaseId() === id) {
             resolve(viewer);
             this.onViewerAddedObservable.removeCallback(viewerFunction);
         }
     }
     this.onViewerAddedObservable.add(viewerFunction);
 });

        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) => {

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

 private _onViewerAdded(viewer: AbstractViewer) {
     this.onViewerAdded && this.onViewerAdded(viewer);
     this.onViewerAddedObservable.notifyObservers(viewer);
 }

 let viewerFunction = (viewer: AbstractViewer) => {
     if (viewer.getBaseId() === id) {
         resolve(viewer);
         this.onViewerAddedObservable.removeCallback(viewerFunction);
     }
 }

 /**
  * remove a viewer from the viewer manager
  * @param viewer the viewer to remove
  */
 public removeViewer(viewer: AbstractViewer) {
     let id = viewer.getBaseId();
     delete this._viewers[id];
     this.onViewerRemovedObservable.notifyObservers(id);
 }