@combeenation/3d-viewer 4.2.0 → 4.3.0-alpha1

package/src/api/manager/animationManager.ts

@@ -9,109 +9,134 @@ import { PlacementAnimation } from '../classes/placementAnimation';
 
 //gsap.registerPlugin( CustomEase, ExpoScaleEase, RoughEase, SlowMo );
 
+export class AnimationManager {
+  public animations: AnimationInterface[] = [];
 
-export class AnimationManager  {
+  /**
+   * Constructor.
+   */
+  protected constructor(protected scene: Scene) {}
 
-	public animations: AnimationInterface[] = [];
+  /**
+   * Creates an {@link AnimationManager} based on given BabylonJS scene.
+   */
+  public static async create(scene: BabylonScene): Promise<AnimationManager> {
+    return new AnimationManager(scene);
+  }
 
-	/**
-	 * Constructor.
-	 */
-	protected constructor( protected scene: Scene ) {
-	}
+  /**
+   * @deprecated Use viewer.moveCameraTo().
+   */
+  public resetCamera(animate: boolean = false) {
+    //TODO currently only works for arcrotate. are there any other cameras?
+    let activeCamera = this.scene.activeCamera as Nullable<ArcRotateCamera>;
+    if (!activeCamera) {
+      throw new Error('There is no active camera');
+    }
 
-	/**
-	 * Creates an {@link AnimationManager} based on given BabylonJS scene.
-	 */
-	public static async create( scene: BabylonScene ): Promise<AnimationManager> {
-		return new AnimationManager( scene );
-	}
+    const initAlpha = activeCamera.metadata.alpha;
+    const initBeta = activeCamera.metadata.beta;
+    const initRadius = activeCamera.metadata.radius;
 
-	/**
-	 * @deprecated Use viewer.moveCameraTo().
-	 */
-	public resetCamera(animate: boolean = false) {
-		//TODO currently only works for arcrotate. are there any other cameras?
-		let activeCamera = this.scene.activeCamera as Nullable<ArcRotateCamera>;
-		if( ! activeCamera ) {
-			throw new Error( 'There is no active camera' );
-		}
+    if (animate) {
+      this.animateArcRotateCamera(initAlpha, initBeta, initRadius);
+    } else {
+      activeCamera.alpha = initAlpha;
+      activeCamera.beta = initBeta;
+      activeCamera.radius = initRadius;
+    }
+  }
 
-		const initAlpha = activeCamera.metadata.alpha;
-		const initBeta = activeCamera.metadata.beta;
-		const initRadius = activeCamera.metadata.radius;
+  /**
+   * @deprecated Use viewer.moveCameraTo().
+   */
+  public animateArcRotateCamera(targetAlpha: number, targetBeta: number, targetRadius: number) {
+    let activeCamera = this.scene.activeCamera as Nullable<ArcRotateCamera>;
+    if (!activeCamera) {
+      throw new Error('There is no active camera');
+    }
+    const alphaAnimation = new BabylonAnimation(
+      'alphaAnimation',
+      'alpha',
+      30,
+      BabylonAnimation.ANIMATIONTYPE_FLOAT,
+      BabylonAnimation.ANIMATIONLOOPMODE_CONSTANT
+    );
+    const betaAnimation = new BabylonAnimation(
+      'betaAnimation',
+      'beta',
+      30,
+      BabylonAnimation.ANIMATIONTYPE_FLOAT,
+      BabylonAnimation.ANIMATIONLOOPMODE_CONSTANT
+    );
+    const radiusAnimation = new BabylonAnimation(
+      'radiusAnimation',
+      'radius',
+      30,
+      BabylonAnimation.ANIMATIONTYPE_FLOAT,
+      BabylonAnimation.ANIMATIONLOOPMODE_CONSTANT
+    );
+    alphaAnimation.setKeys([
+      {
+        frame: 0,
+        value: activeCamera.alpha,
+      },
+      {
+        frame: 100,
+        value: targetAlpha,
+      },
+    ]);
+    betaAnimation.setKeys([
+      {
+        frame: 0,
+        value: activeCamera.beta,
+      },
+      {
+        frame: 100,
+        value: targetBeta,
+      },
+    ]);
+    radiusAnimation.setKeys([
+      {
+        frame: 0,
+        value: activeCamera.radius,
+      },
+      {
+        frame: 100,
+        value: targetRadius,
+      },
+    ]);
+    activeCamera.animations.push(alphaAnimation);
+    activeCamera.animations.push(betaAnimation);
+    activeCamera.animations.push(radiusAnimation);
 
-		if( animate ) {
-			this.animateArcRotateCamera(initAlpha, initBeta, initRadius);
-		} else {
-			activeCamera.alpha = initAlpha;
-			activeCamera.beta = initBeta;
-			activeCamera.radius = initRadius;
-		}
-	}
+    let animation = this.scene.beginAnimation(activeCamera, 0, 100, false, 10);
+    animation.disposeOnEnd = true;
+  }
 
-	/**
-	 * @deprecated Use viewer.moveCameraTo().
-	 */
-	public animateArcRotateCamera(targetAlpha: number, targetBeta: number, targetRadius: number) {
-		let activeCamera = this.scene.activeCamera as Nullable<ArcRotateCamera>;
-		if( ! activeCamera ) {
-			throw new Error( 'There is no active camera' );
-		}
-		const alphaAnimation = new BabylonAnimation( 'alphaAnimation', 'alpha', 30, BabylonAnimation.ANIMATIONTYPE_FLOAT, BabylonAnimation.ANIMATIONLOOPMODE_CONSTANT );
-		const betaAnimation = new BabylonAnimation( 'betaAnimation', 'beta', 30, BabylonAnimation.ANIMATIONTYPE_FLOAT, BabylonAnimation.ANIMATIONLOOPMODE_CONSTANT );
-		const radiusAnimation = new BabylonAnimation( 'radiusAnimation', 'radius', 30, BabylonAnimation.ANIMATIONTYPE_FLOAT, BabylonAnimation.ANIMATIONLOOPMODE_CONSTANT );
-		alphaAnimation.setKeys([{
-			frame : 0,
-			value : activeCamera.alpha
-		}, {
-			frame : 100,
-			value : targetAlpha
-		}]);
-		betaAnimation.setKeys([{
-			frame : 0,
-			value : activeCamera.beta
-		}, {
-			frame : 100,
-			value : targetBeta
-		}]);
-		radiusAnimation.setKeys( [{
-			frame : 0,
-			value : activeCamera.radius
-		}, {
-			frame : 100,
-			value : targetRadius
-		}]);
-		activeCamera.animations.push(alphaAnimation);
-		activeCamera.animations.push(betaAnimation);
-		activeCamera.animations.push(radiusAnimation);
+  /**
+   * Stops and kills all running animations.
+   */
+  public killAllAnimations() {
+    this.animations.forEach(animation => animation.kill());
+    this.animations = [];
+  }
 
-		let animation = this.scene.beginAnimation(activeCamera, 0, 100, false, 10);
-		animation.disposeOnEnd = true;
-	}
-
-	/**
-	 * Stops and kills all running animations.
-	 */
-	public killAllAnimations() {
-		this.animations.forEach( animation => animation.kill() );
-		this.animations = [];
-	}
-
-	/**
-	 * @see {@link PlacementAnimation.play}
-	 */
-	public async animateToPlacement( mutable: object,
-	                                 placement: PlacementDefinition | string,
-	                                 animation?: AnimationDefinition | string ): Promise<AnimationInterface> {
-		const _animation = new PlacementAnimation( mutable, placement, animation );
-		this.animations.push( _animation );
-		const animationPromise = _animation.play();
-		animationPromise.then( a => {
-			remove( this.animations, _a => _a === a );
-			a.kill();
-		} );
-		return await animationPromise;
-	}
-
-}
+  /**
+   * @see {@link PlacementAnimation.play}
+   */
+  public async animateToPlacement(
+    mutable: object,
+    placement: PlacementDefinition | string,
+    animation?: AnimationDefinition | string
+  ): Promise<AnimationInterface> {
+    const _animation = new PlacementAnimation(mutable, placement, animation);
+    this.animations.push(_animation);
+    const animationPromise = _animation.play();
+    animationPromise.then(a => {
+      remove(this.animations, _a => _a === a);
+      a.kill();
+    });
+    return await animationPromise;
+  }
+}

package/src/api/manager/sceneManager.ts

@@ -8,98 +8,95 @@ import { SpecStorage } from '../store/specStorage';
 import { mergeMaps } from '../util/resourceHelper';
 
 export class SceneManager extends ParameterObservable {
+  protected readonly _parameterObservers: Map<string, ParameterObserver[]> = new Map();
 
-	protected readonly _parameterObservers: Map<string, ParameterObserver[]> = new Map();
+  protected readonly parameterDeclaration: ParameterDeclarations = {
+    'environment': { type: 'string' },
+    'environment.rotation': { type: 'number' },
+  };
 
-	protected readonly parameterDeclaration: ParameterDeclarations = {
-		'environment': { type: 'string' },
-		'environment.rotation': { type: 'number' }
-	};
+  /**
+   * Constructor.
+   */
+  protected constructor(public scene: BabylonScene) {
+    super();
+    this.addParameterObservers();
+  }
 
-	/**
-	 * Constructor.
-	 */
-	protected constructor( public scene: BabylonScene ) {
-		super();
-		this.addParameterObservers();
-	}
+  /**
+   * Creates a {@link SceneManager} based on given BabylonJS scene.
+   */
+  public static async create(scene: BabylonScene): Promise<SceneManager> {
+    const sceneManager = new SceneManager(scene);
+    await sceneManager.bootstrapParameters(SpecStorage.get<ParameterBag>('scene.parameters'));
+    return sceneManager;
+  }
 
-	/**
-	 * Creates a {@link SceneManager} based on given BabylonJS scene.
-	 */
-	public static async create( scene: BabylonScene ): Promise<SceneManager> {
-		const sceneManager = new SceneManager( scene );
-		await sceneManager.bootstrapParameters( SpecStorage.get<ParameterBag>( 'scene.parameters' ) );
-		return sceneManager;
-	}
+  /**
+   * The active `Camera`.
+   */
+  get activeCamera(): Camera {
+    if (!this.scene.activeCamera) {
+      throw new Error('Scene has no active camera.');
+    }
+    return this.scene.activeCamera;
+  }
 
-	/**
-	 * The active `Camera`.
-	 */
-	get activeCamera(): Camera {
-		if( !this.scene.activeCamera ) {
-			throw new Error( 'Scene has no active camera.' );
-		}
-		return this.scene.activeCamera;
-	}
+  /**
+   * Places the given {@link ParameterBag} in the {@link SceneManager}'s parameters, replaces all patterns in the
+   * {@link StructureJson} and broadcasts all {@link ParameterObserver}s.
+   *
+   * @emit {@link Event.SCENE_PARAMETER_COMMITTED}
+   */
+  public async commitParameters(parameters?: ParameterBag): Promise<SceneManager> {
+    if (!parameters) {
+      parameters = {};
+    }
+    const oldParameters = cloneDeep(this.parameters);
+    merge(this.parameters, parameters);
 
-	/**
-	 * Places the given {@link ParameterBag} in the {@link SceneManager}'s parameters, replaces all patterns in the
-	 * {@link StructureJson} and broadcasts all {@link ParameterObserver}s.
-	 *
-	 * @emit {@link Event.SCENE_PARAMETER_COMMITTED}
-	 */
-	public async commitParameters( parameters?: ParameterBag ): Promise<SceneManager> {
-		if( !parameters ) {
-			parameters = {};
-		}
-		const oldParameters = cloneDeep( this.parameters );
-		merge( this.parameters, parameters );
+    // handle parameter observers
+    for (const parameter in this.parameters) {
+      const oldParameterValue = oldParameters[parameter];
+      const newParameterValue = this.parameters[parameter];
+      this.assertParameter(this.parameterDeclaration, parameter, newParameterValue);
+      if (oldParameterValue === newParameterValue) {
+        continue;
+      }
+      // parameter changed
+      const parameterObservers = mergeMaps(this._parameterObservers, this.parameterObservers);
+      if (parameterObservers.has(parameter)) {
+        const observers = parameterObservers.get(parameter)!;
+        observers.forEach(observer => {
+          observer(this, oldParameterValue, newParameterValue);
+          this.broadcastEvent(Event.SCENE_PARAMETER_COMMITTED, this, parameter, oldParameterValue, newParameterValue);
+        });
+      }
+    }
+    return this;
+  }
 
-		// handle parameter observers
-		for( const parameter in this.parameters ) {
-			const oldParameterValue = oldParameters[parameter];
-			const newParameterValue = this.parameters[parameter];
-			this.assertParameter( this.parameterDeclaration, parameter, newParameterValue );
-			if( oldParameterValue === newParameterValue ) {
-				continue;
-			}
-			// parameter changed
-			const parameterObservers = mergeMaps( this._parameterObservers, this.parameterObservers );
-			if( parameterObservers.has( parameter ) ) {
-				const observers = parameterObservers.get( parameter )!;
-				observers.forEach( observer => {
-					observer( this, oldParameterValue, newParameterValue );
-					this.broadcastEvent( Event.SCENE_PARAMETER_COMMITTED, this, parameter,
-						oldParameterValue, newParameterValue );
-				} );
-			}
-		}
-		return this;
-	}
-
-	protected addParameterObservers(): SceneManager {
-		this._parameterObservers.set( 'environment', [
-			( manager: SceneManager, oldValue: ParameterValue, newValue: ParameterValue ) => {
-				manager.scene.environmentTexture = CubeTexture.CreateFromPrefilteredData( newValue.toString(), manager.scene );
-			}
-		] );
-		this._parameterObservers.set( 'environment.rotation', [
-			( manager: SceneManager, oldValue: ParameterValue, newValue: ParameterValue ) => {
-				if( manager.scene.environmentTexture instanceof CubeTexture ) {
-					manager.scene.environmentTexture.rotationY = (parseFloat( newValue.toString() ) * Math.PI) / 180;
-				}
-			}
-		] );
-		return this;
-	}
-
-	/**
-	 * Bootstrapping for parameters. It sets the `parametersInitialized` to true for all ancestors.
-	 */
-	protected async bootstrapParameters( parameters?: ParameterBag ): Promise<SceneManager> {
-		await this.commitParameters( merge( cloneDeep( this.parameters ), parameters ) );
-		return this;
-	}
+  protected addParameterObservers(): SceneManager {
+    this._parameterObservers.set('environment', [
+      (manager: SceneManager, oldValue: ParameterValue, newValue: ParameterValue) => {
+        manager.scene.environmentTexture = CubeTexture.CreateFromPrefilteredData(newValue.toString(), manager.scene);
+      },
+    ]);
+    this._parameterObservers.set('environment.rotation', [
+      (manager: SceneManager, oldValue: ParameterValue, newValue: ParameterValue) => {
+        if (manager.scene.environmentTexture instanceof CubeTexture) {
+          manager.scene.environmentTexture.rotationY = (parseFloat(newValue.toString()) * Math.PI) / 180;
+        }
+      },
+    ]);
+    return this;
+  }
 
+  /**
+   * Bootstrapping for parameters. It sets the `parametersInitialized` to true for all ancestors.
+   */
+  protected async bootstrapParameters(parameters?: ParameterBag): Promise<SceneManager> {
+    await this.commitParameters(merge(cloneDeep(this.parameters), parameters));
+    return this;
+  }
 }