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

package/src/api/classes/variantInstance.ts

@@ -1,82 +1,89 @@
-import { Mesh } from '@babylonjs/core/Meshes/mesh';
-import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
-import { Element } from './element';
-import { EventBroadcaster } from './eventBroadcaster';
-import { ParameterObservable } from './parameterObservable';
-import { Variant } from './variant';
-
-/**
- * Class VariantInstance.
- */
-export class VariantInstance extends EventBroadcaster {
-
-	/**
-	 * Constructor
-	 */
-	public constructor( public variant: Variant, public name: string ) {
-		super();
-	}
-
-	/**
-	 * WORK IN PROGRESS
-	 */
-	public translate( joint: DottedPathArgument, variantInstance: VariantInstance, variantInstanceJoint: DottedPathArgument ): VariantInstance {
-		/*
-		joint = DottedPath.create( joint );
-		variantInstanceJoint = DottedPath.create( variantInstanceJoint );
-		const jointNode = variantInstance.variant.getNode( joint.path );
-		const variantInstanceJointNode = variantInstance.variant.getNode( variantInstanceJoint.path );
-		const differenceVector = variantInstanceJointNode.getAbsolutePosition().subtract( jointNode.getAbsolutePosition() );
-		const differenceVectorRotation = variantInstanceJointNode.rotation.subtract( jointNode.rotation );
-
-		console.log( variantInstanceJointNode.rotationQuaternion, 'ROTATION' );
-
-		this.variant.nodes.forEach( node => {
-			node.translate( Axis.X, differenceVector.x, Space.WORLD );
-			node.translate( Axis.Y, differenceVector.y, Space.WORLD );
-			node.translate( Axis.Z, differenceVector.z, Space.WORLD );
-
-			node.rotateAround( Axis.Y, differenceVectorRotation, 20 );
-			// node.rotate(Axis.Y, differenceVectorRotation.y, Space.WORLD );
-			// node.rotate(Axis.Z, differenceVectorRotation.z, Space.WORLD );
-		} );
-		*/
-		return this;
-	}
-
-	/**
-	 * A proxy for {@link Variant.getElement}.
-	 */
-	public async getElement( dottedPath: DottedPathArgument ): Promise<Element> {
-		return this.variant.getElement( dottedPath );
-	}
-
-	/**
-	 * A proxy for {@link Variant.getNode}.
-	 */
-	public async getNode( elementDottedPath: DottedPathArgument, nodeDottedPath: DottedPathArgument ): Promise<TransformNode> {
-		return this.variant.getNode( elementDottedPath, nodeDottedPath );
-	}
-
-	/**
-	 * A proxy for {@link Variant.getMesh}.
-	 */
-	public async getMesh( elementDottedPath: DottedPathArgument, meshDottedPath: DottedPathArgument ): Promise<Mesh|null> {
-		return this.variant.getMesh( elementDottedPath, meshDottedPath );
-	}
-
-	/**
-	 * A proxy for {@link Variant.commitParameters}.
-	 */
-	public async commitParameters( parameters?: ParameterBag ): Promise<Variant> {
-		return this.variant.commitParameters( parameters );
-	}
-
-	/**
-	 * A proxy for {@link ParameterObservable.commitParameter}.
-	 */
-	public async commitParameter( parameter: string, value: ParameterValue ): Promise<ParameterObservable> {
-		return this.variant.commitParameter( parameter, value );
-	}
-
+import { Mesh } from '@babylonjs/core/Meshes/mesh';
+import { Element } from './element';
+import { ViewerLight } from './viewerLight';
+import { EventBroadcaster } from './eventBroadcaster';
+import { ParameterObservable } from './parameterObservable';
+import { Variant } from './variant';
+
+/**
+ * Class VariantInstance.
+ */
+export class VariantInstance extends EventBroadcaster {
+
+	/**
+	 * Constructor
+	 */
+	public constructor( public variant: Variant, public name: string ) {
+		super();
+	}
+
+	/**
+	 * WORK IN PROGRESS
+	 */
+	public translate( joint: DottedPathArgument, variantInstance: VariantInstance, variantInstanceJoint: DottedPathArgument ): VariantInstance {
+		/*
+		joint = DottedPath.create( joint );
+		variantInstanceJoint = DottedPath.create( variantInstanceJoint );
+		const jointNode = variantInstance.variant.getNode( joint.path );
+		const variantInstanceJointNode = variantInstance.variant.getNode( variantInstanceJoint.path );
+		const differenceVector = variantInstanceJointNode.getAbsolutePosition().subtract( jointNode.getAbsolutePosition() );
+		const differenceVectorRotation = variantInstanceJointNode.rotation.subtract( jointNode.rotation );
+
+		console.log( variantInstanceJointNode.rotationQuaternion, 'ROTATION' );
+
+		this.variant.nodes.forEach( node => {
+			node.translate( Axis.X, differenceVector.x, Space.WORLD );
+			node.translate( Axis.Y, differenceVector.y, Space.WORLD );
+			node.translate( Axis.Z, differenceVector.z, Space.WORLD );
+
+			node.rotateAround( Axis.Y, differenceVectorRotation, 20 );
+			// node.rotate(Axis.Y, differenceVectorRotation.y, Space.WORLD );
+			// node.rotate(Axis.Z, differenceVectorRotation.z, Space.WORLD );
+		} );
+		*/
+		return this;
+	}
+
+	/**
+	 * A proxy for {@link Variant.getElement}.
+	 */
+	public async getElement( dottedPath: DottedPathArgument ): Promise<Element> {
+		return this.variant.getElement( dottedPath );
+	}
+
+	/**
+	 * A proxy for {@link Variant.getViewerLight}.
+	 */
+	public async getViewerLight( dottedPath: DottedPathArgument ): Promise<ViewerLight> {
+		return this.variant.getViewerLight( dottedPath );
+	}
+
+	/**
+	 * A proxy for {@link Variant.getNode}.
+	 */
+	public async getNode( elementDottedPath: DottedPathArgument, nodeDottedPath: DottedPathArgument ): Promise<TransformNode> {
+		return this.variant.getNode( elementDottedPath, nodeDottedPath );
+	}
+
+	/**
+	 * A proxy for {@link Variant.getMesh}.
+	 */
+	public async getMesh( elementDottedPath: DottedPathArgument, meshDottedPath: DottedPathArgument ): Promise<Mesh|null> {
+		return this.variant.getMesh( elementDottedPath, meshDottedPath );
+	}
+
+	/**
+	 * A proxy for {@link Variant.commitParameters}.
+	 */
+	public async commitParameters( parameters?: ParameterBag ): Promise<Variant> {
+		return this.variant.commitParameters( parameters );
+	}
+
+	/**
+	 * A proxy for {@link ParameterObservable.commitParameter}.
+	 */
+	public async commitParameter( parameter: string, value: ParameterValue ): Promise<ParameterObservable> {
+		return this.variant.commitParameter( parameter, value );
+	}
+
 }

package/src/api/classes/variantParameterizable.ts

@@ -0,0 +1,73 @@
+import { DottedPath } from './../classes/dottedPath';
+import { Event } from './../classes/event';
+import { Parameterizable } from './../classes/parameterizable';
+import { Variant } from './../classes/variant';
+import { mergeMaps } from './../util/resourceHelper';
+import { camelToSnakeCase } from './../util/stringHelper';
+import { cloneDeep, concat, get, merge } from 'lodash-es';
+
+export abstract class VariantParameterizable extends Parameterizable {
+
+	protected readonly _parameterObservers: Map<string, ParameterObserver[]> = new Map();
+
+	protected constructor( public readonly variant: Variant,
+	                       public readonly name: string ) {
+		super();
+	}
+
+	/**
+	 * Gets the inherited parameters from the {@link Variant} with cleaned {@link Parameterizable} prefix.
+	 */
+	get inheritedParameters(): ParameterBag {
+		const parameterBag: ParameterBag = {};
+		for( const parameter in this.variant.inheritedParameters ) {
+			const dpp = DottedPath.create( parameter );
+			if( dpp.firstPart !== this.name ) {
+				continue;
+			}
+			dpp.shiftPart();
+			parameterBag[dpp.path] = this.variant.inheritedParameters[parameter];
+		}
+		return parameterBag;
+	}
+
+	/**
+	 * Places the given {@link ParameterBag} in the {@link VariantParameterizable}'s parameters, replaces all patterns in the
+	 * {@link StructureJson} and broadcasts all {@link ParameterObserver}s.
+	 */
+	public async commitParameters( parameters?: ParameterBag ): Promise<VariantParameterizable> {
+		if( !parameters ) {
+			parameters = {};
+		}
+		const oldParameters = cloneDeep( this.parameters );
+		merge( this.parameters, parameters );
+		// handle parameter observers
+		let observerPromises: Promise<void | ParameterObserver>[] = [];
+		for( const parameter in this.parameters ) {
+			const oldParameterValue = oldParameters[parameter];
+			const newParameterValue = this.parameters[parameter];
+			this.variant.assertParameter( this.variant.inheritedParameterDeclaration, parameter, newParameterValue );
+			if( oldParameterValue === newParameterValue ) {
+				continue;
+			}
+			// parameter changed
+			const parameterObservers = mergeMaps( this._parameterObservers, this.parameterObservers );
+			if( parameterObservers.has( parameter ) ) {
+				const observers = parameterObservers.get( parameter )!;
+				observerPromises = concat( observerPromises, observers.map( observer => {
+					const observerResult = observer( this, oldParameterValue, newParameterValue );
+					const observerPromise = Promise.resolve( observerResult );
+					observerPromise.then( () => {
+						const clsName = camelToSnakeCase( this.constructor.name ).toUpperCase();
+						this.broadcastEvent( get( Event, clsName + '_PARAMETER_COMMITTED' ),
+							this, parameter, oldParameterValue, newParameterValue );
+					} );
+					return observerPromise;
+				} ) );
+			}
+		}
+		await Promise.all( observerPromises );
+		return this;
+	}
+
+}