@combeenation/3d-viewer 4.0.0-beta5 → 4.0.0-rc1

package/src/api/manager/animationManager.ts

@@ -1,117 +1,117 @@
-import { Animation as BabylonAnimation } from '@babylonjs/core/Animations/animation';
-import { ArcRotateCamera } from '@babylonjs/core/Cameras/arcRotateCamera';
-import { Scene as BabylonScene, Scene } from '@babylonjs/core/scene';
-import { Nullable } from '@babylonjs/core/types';
-//import { CustomEase } from 'gsap/CustomEase';
-//import { ExpoScaleEase, RoughEase, SlowMo } from 'gsap/EasePack';
-import { remove } from 'lodash-es';
-import { PlacementAnimation } from '../classes/placementAnimation';
-
-//gsap.registerPlugin( CustomEase, ExpoScaleEase, RoughEase, SlowMo );
-
-
-export class AnimationManager  {
-
-	public animations: AnimationInterface[] = [];
-
-	/**
-	 * Constructor.
-	 */
-	protected constructor( protected scene: Scene ) {
-	}
-
-	/**
-	 * Creates an {@link AnimationManager} based on given BabylonJS scene.
-	 */
-	public static async create( scene: BabylonScene ): Promise<AnimationManager> {
-		return new AnimationManager( 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' );
-		}
-
-		const initAlpha = activeCamera.metadata.alpha;
-		const initBeta = activeCamera.metadata.beta;
-		const initRadius = activeCamera.metadata.radius;
-
-		if( animate ) {
-			this.animateArcRotateCamera(initAlpha, initBeta, initRadius);
-		} else {
-			activeCamera.alpha = initAlpha;
-			activeCamera.beta = initBeta;
-			activeCamera.radius = initRadius;
-		}
-	}
-
-	/**
-	 * @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);
-
-		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;
-	}
-
+import { Animation as BabylonAnimation } from '@babylonjs/core/Animations/animation';
+import { ArcRotateCamera } from '@babylonjs/core/Cameras/arcRotateCamera';
+import { Scene as BabylonScene, Scene } from '@babylonjs/core/scene';
+import { Nullable } from '@babylonjs/core/types';
+//import { CustomEase } from 'gsap/CustomEase';
+//import { ExpoScaleEase, RoughEase, SlowMo } from 'gsap/EasePack';
+import { remove } from 'lodash-es';
+import { PlacementAnimation } from '../classes/placementAnimation';
+
+//gsap.registerPlugin( CustomEase, ExpoScaleEase, RoughEase, SlowMo );
+
+
+export class AnimationManager  {
+
+	public animations: AnimationInterface[] = [];
+
+	/**
+	 * Constructor.
+	 */
+	protected constructor( protected scene: Scene ) {
+	}
+
+	/**
+	 * Creates an {@link AnimationManager} based on given BabylonJS scene.
+	 */
+	public static async create( scene: BabylonScene ): Promise<AnimationManager> {
+		return new AnimationManager( 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' );
+		}
+
+		const initAlpha = activeCamera.metadata.alpha;
+		const initBeta = activeCamera.metadata.beta;
+		const initRadius = activeCamera.metadata.radius;
+
+		if( animate ) {
+			this.animateArcRotateCamera(initAlpha, initBeta, initRadius);
+		} else {
+			activeCamera.alpha = initAlpha;
+			activeCamera.beta = initBeta;
+			activeCamera.radius = initRadius;
+		}
+	}
+
+	/**
+	 * @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);
+
+		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;
+	}
+
 }

package/src/api/manager/sceneManager.ts

@@ -1,105 +1,105 @@
-import { Camera } from '@babylonjs/core/Cameras/camera';
-import { CubeTexture } from '@babylonjs/core/Materials/Textures/cubeTexture';
-import { Scene as BabylonScene } from '@babylonjs/core/scene';
-import { cloneDeep, merge } from 'lodash-es';
-import { ParameterObservable } from '../classes/parameterObservable';
-import { Event } from '../classes/event';
-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 parameterDeclaration: ParameterDeclarations = {
-		'environment': { type: 'string' },
-		'environment.rotation': { type: 'number' }
-	};
-
-	/**
-	 * 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;
-	}
-
-	/**
-	 * 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 );
-
-		// 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;
-	}
-
-}
+import { Camera } from '@babylonjs/core/Cameras/camera';
+import { CubeTexture } from '@babylonjs/core/Materials/Textures/cubeTexture';
+import { Scene as BabylonScene } from '@babylonjs/core/scene';
+import { cloneDeep, merge } from 'lodash-es';
+import { ParameterObservable } from '../classes/parameterObservable';
+import { Event } from '../classes/event';
+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 parameterDeclaration: ParameterDeclarations = {
+		'environment': { type: 'string' },
+		'environment.rotation': { type: 'number' }
+	};
+
+	/**
+	 * 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;
+	}
+
+	/**
+	 * 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 );
+
+		// 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;
+	}
+
+}