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

package/src/api/classes/viewerLight.ts

@@ -1,330 +0,0 @@
-import { PointLight } from '@babylonjs/core';
-import { HemisphericLight } from '@babylonjs/core/Lights/hemisphericLight';
-import { Light } from '@babylonjs/core/Lights/light';
-import { ShadowLight } from '@babylonjs/core/Lights/shadowLight';
-import { ShadowGenerator } from '@babylonjs/core/Lights/Shadows/shadowGenerator';
-import '@babylonjs/core/Lights/Shadows/shadowGeneratorSceneComponent';
-import { Vector3 } from '@babylonjs/core/Maths/math.vector';
-import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
-import '@babylonjs/loaders/glTF/2.0/Extensions/KHR_lights_punctual';
-import { get, isEmpty, isString, set } from 'lodash-es';
-import {
-	cloneNodeWithParents,
-	disableNodeWithParents,
-	enableNodeWithParents,
-	getRootNode,
-	injectNodeMetadata,
-	moveTransformNode,
-	rotateTransformNode
-} from './../util/babylonHelper';
-import { DottedPath } from './dottedPath';
-import { Parameter } from './parameter';
-import { Variant } from './variant';
-import { VariantParameterizable } from './variantParameterizable';
-
-/**
- * A {@link ViewerLight} of a {@link Variant}. Acts as a container for BabylonJS lights. Lives only in the context of a
- * {@link Variant}.
- */
-export class ViewerLight extends VariantParameterizable {
-
-	protected _light: Light | undefined;
-
-	/**
-	 * Constructor.
-	 */
-	protected constructor( public readonly variant: Variant,
-	                       public readonly name: string ) {
-		super( variant, name );
-		this.addParameterObservers();
-	}
-
-	/**
-	 * Creates a {@link ViewerLight} with given name.
-	 */
-	public static async create( variant: Variant, name: string ): Promise<ViewerLight> {
-		const viewerLight = new ViewerLight( variant, name );
-		viewerLight._light = await viewerLight.createBabylonLightFromDefinition( viewerLight.definition );
-		return viewerLight;
-	}
-
-	/**
-	 * The wrapped Light.
-	 */
-	get light(): Light {
-		if( !this._light ) {
-			throw new Error( `Light for ViewerLight "${this.name}" has not been properly initialized.` );
-		}
-		return this._light!;
-	}
-
-	/**
-	 * The {@link DottedPath} in the built tree of {@link ViewerLight}s.
-	 * E.g. "_.top-1.sub-2.sub-sub-3.el-1"
-	 */
-	get dottedPath(): DottedPath {
-		return DottedPath.create( this.variant.dottedPath ).addPart( this.name );
-	}
-
-	/**
-	 * The id representing a {@link DottedPath}.
-	 */
-	get id(): string {
-		const dottedPath = DottedPath.create( this.dottedPath );
-		dottedPath.shiftPart();  // remove root
-		return dottedPath.path;
-	}
-
-	/**
-	 * The {@link LightDefinition} of the {@link ViewerLight}.
-	 */
-	get definition(): LightDefinition {
-		const definition = this.variant.structureJson.lights![this.name];
-		if( isString( definition ) ) {
-			return {
-				type: 'baked',
-				path: definition
-			} as LightDefinition;
-		}
-		return definition as LightDefinition;
-	}
-
-	/**
-	 * The type of the {@link ViewerLight}'s light.
-	 */
-	get type(): string {
-		return this.light.constructor.name.replace( /light/i, '' ).toLowerCase();
-	}
-
-	/**
-	 * @see {@link VariantParameterizable.commitParameters}
-	 * @emit {@link Event.VIEWER_LIGHT_PARAMETER_COMMITTED}
-	 */
-	public async commitParameters( parameters?: ParameterBag ): Promise<VariantParameterizable> {
-		return super.commitParameters( parameters );
-	}
-
-	/**
-	 * Adds the default {@link ParameterObserver}s which are called every time {@link commitParameters} is called.
-	 */
-	protected addParameterObservers(): ViewerLight {
-		this._parameterObservers.set( Parameter.VISIBLE, [
-			async ( light: ViewerLight, oldValue: ParameterValue, newValue: ParameterValue ) => {
-				let visible;
-				try {
-					visible = Parameter.parseBoolean( newValue );
-				} catch( e ) {
-					return;
-				}
-				if( visible === true ) {
-					enableNodeWithParents( light.light );
-				} else if( visible === false ) {
-					disableNodeWithParents( light.light );
-				}
-			}
-		] );
-		this._parameterObservers.set( Parameter.INTENSITY, [
-			async ( light: ViewerLight, oldValue: ParameterValue, newValue: ParameterValue ) => {
-				set( light.light, 'intensity', Parameter.parseNumber( newValue ) );
-			}
-		] );
-		this._parameterObservers.set( Parameter.POSITION, [
-			async ( light: ViewerLight, oldValue: ParameterValue, newValue: ParameterValue ) => {
-				// we have to deal just with root nodes here due to relative impacts in a node tree
-				const rootNode = getRootNode( light.light );
-				if( rootNode instanceof TransformNode ) {
-					moveTransformNode( rootNode, Parameter.parseVector( newValue ) );
-				}
-			}
-		] );
-		this._parameterObservers.set( Parameter.ROTATION, [
-			async ( light: ViewerLight, oldValue: ParameterValue, newValue: ParameterValue ) => {
-				// The current implementation (rotating around coordinates 0,0,0) implicitly mutates the position of a node.
-				// Since a user expects the rotation after the positioning, we have to manually fire the position observers.
-				// Without calling these observers, the pivot and the position of a node is initially the same before rotating,
-				// so there is no rotation happening at all.
-				if( Parameter.POSITION in light.inheritedParameters ) {
-					await light.commitParameter( Parameter.POSITION, light.inheritedParameters[Parameter.POSITION] );
-				}
-				// we have to deal just with root nodes here due to relative impacts in a node tree
-				const rootNode = getRootNode( light.light );
-				if( rootNode instanceof TransformNode ) {
-					rotateTransformNode( rootNode, Parameter.parseRotation( newValue ) );
-				}
-			}
-		] );
-		this._parameterObservers.set( Parameter.SCALING, [
-			async ( light: ViewerLight, oldValue: ParameterValue, newValue: ParameterValue ) => {
-				// we have to deal just with root nodes here due to relative impacts in a node tree
-				const rootNode = getRootNode( light.light );
-				if( rootNode instanceof TransformNode ) {
-					rootNode.scaling = Parameter.parseScaling( newValue );
-				}
-			}
-		] );
-		this._parameterObservers.set( Parameter.DIRECTION, [
-			async ( light: ViewerLight, oldValue: ParameterValue, newValue: ParameterValue ) => {
-				if(
-					(light.light instanceof ShadowLight && !(light.light instanceof PointLight))
-					|| light.light instanceof HemisphericLight
-				) {
-					set( light.light, 'direction', Parameter.parseVector( newValue ) );
-				}
-			}
-		] );
-		this._parameterObservers.set( Parameter.ANGLE, [
-			async ( light: ViewerLight, oldValue: ParameterValue, newValue: ParameterValue ) => {
-				if( light.light.getClassName() === 'SpotLight' ) {
-					set( light.light, 'angle', Parameter.parseNumber( newValue ) );
-				}
-			}
-		] );
-		this._parameterObservers.set( Parameter.EXPONENT, [
-			async ( light: ViewerLight, oldValue: ParameterValue, newValue: ParameterValue ) => {
-				if( light.light.getClassName() === 'SpotLight' ) {
-					set( light.light, 'exponent', Parameter.parseNumber( newValue ) );
-				}
-			}
-		] );
-		this._parameterObservers.set( Parameter.DIFFUSE, [
-			async ( light: ViewerLight, oldValue: ParameterValue, newValue: ParameterValue ) => {
-				set( light.light, 'diffuse', Parameter.parseColor( newValue ) );
-			}
-		] );
-		this._parameterObservers.set( Parameter.SPECULAR, [
-			async ( light: ViewerLight, oldValue: ParameterValue, newValue: ParameterValue ) => {
-				set( light.light, 'specular', Parameter.parseColor( newValue ) );
-			}
-		] );
-		return this;
-	}
-
-	/**
-	 * @param definition
-	 * @protected
-	 */
-	protected async createBabylonLightFromDefinition( definition: LightDefinition ): Promise<Light> {
-		const parameters = Parameter.parseFromDeclarations( Parameter.declarations, this.inheritedParameters );
-		const scene = this.variant.viewer.scene;
-		let lightId = this.id;
-		let babylonLight;
-		switch( definition.type ) {
-			case 'baked':
-				if( !definition['path'] ) {
-					throw new Error( `The light "${lightId}" of type "${definition.type}" needs a "path".` );
-				}
-				const bakedLight = this.variant.inheritedLights.find( l => l.metadata.dottedPath.path === definition['path'] );
-				if( bakedLight ) {
-					lightId = bakedLight.metadata.dottedPath.clone().unshiftPart( this.id ).path;
-					babylonLight = cloneNodeWithParents( bakedLight ) as Light;
-					babylonLight!.name = lightId;
-					babylonLight!.id = lightId;
-				} else {
-					throw new Error( `No light found for path "${definition['path']}" in ViewerLight "${lightId}".` );
-				}
-				break;
-			case 'hemispheric':
-				if( !parameters['direction'] ) {
-					throw new Error( `The ViewerLight "${lightId}" of type "${definition.type}" needs a "direction".` );
-				}
-				// @ts-ignore
-				const hemisphericLightModule = await import(/* webpackChunkName: "hemispheric-light" */ '@babylonjs/core/Lights/hemisphericLight');
-				babylonLight = new hemisphericLightModule.HemisphericLight(
-					lightId,
-					parameters['direction'],
-					scene
-				);
-				break;
-			case 'point':
-				// @ts-ignore
-				const pointLightModule = await import(/* webpackChunkName: "point-light" */ '@babylonjs/core/Lights/pointLight');
-				babylonLight = new pointLightModule.PointLight(
-					lightId,
-					Vector3.Zero(),  // position is set via parent TransformNode
-					scene
-				);
-				break;
-			case 'directional':
-				if( !parameters['direction'] ) {
-					throw new Error( `The ViewerLight "${lightId}" of type "${definition.type}" needs a "direction".` );
-				}
-				// @ts-ignore
-				const directionalLightModule = await import(/* webpackChunkName: "directional-light" */ '@babylonjs/core/Lights/directionalLight');
-				babylonLight = new directionalLightModule.DirectionalLight(
-					lightId,
-					parameters['direction'],
-					scene
-				);
-				break;
-			case 'spot':
-				if( !parameters['direction'] ) {
-					throw new Error( `The ViewerLight "${lightId}" of type "${definition.type}" needs a "direction".` );
-				}
-				if( !parameters['angle'] ) {
-					throw new Error( `A ViewerLight of type "${definition.type}" needs an "angle".` );
-				}
-				if( !parameters['exponent'] ) {
-					throw new Error( `The ViewerLight "${lightId}" of type "${definition.type}" needs an "exponent".` );
-				}
-				// @ts-ignore
-				const spotLightModule = await import(/* webpackChunkName: "spot-light" */ '@babylonjs/core/Lights/spotLight');
-				babylonLight = new spotLightModule.SpotLight(
-					lightId,
-					Vector3.Zero(),  // position is set via parent TransformNode
-					parameters['direction'],
-					parameters['angle'],
-					parameters['exponent'],
-					scene
-				);
-				break;
-			default:
-				throw new Error( `The type "${definition.type}" for ViewerLight "${lightId}" is not implemented (yet).` );
-		}
-		if( !babylonLight ) {
-			throw new Error( `The Light for ViewerLight "${lightId}" of type "${definition.type}" could no be created ` +
-				`or found.` );
-		}
-		if( !babylonLight.parent ) {
-			// Create pseudo parent since lights do not implement mutations like "rotation" by itself.
-			babylonLight.parent = new TransformNode( '__light__', this.variant.viewer.scene, true );
-		}
-		injectNodeMetadata( babylonLight.parent, {
-			variant: this.variant,
-			variantParameterizable: this
-		} );
-		// disable/hide by default
-		disableNodeWithParents( babylonLight );
-		// process shadow generator
-		const shadowGeneratorDefinition = get( definition, 'shadowGenerator' ) as ShadowGeneratorDefinition;
-		if( !isEmpty( shadowGeneratorDefinition ) ) {
-			if( !(babylonLight instanceof ShadowLight) ) {
-				throw new Error( `Using a ShadowGenerator with light type "${definition.type}" is not supported for ` +
-					`"${lightId}". Use lights deriving from ShadowLight.` );
-			}
-			await this.processShadowGenerator( babylonLight, shadowGeneratorDefinition );
-		}
-		return babylonLight;
-	};
-
-	/**
-	 * @param babylonLight
-	 * @param definition
-	 * @protected
-	 */
-	protected async processShadowGenerator( babylonLight: ShadowLight,
-	                                        definition: ShadowGeneratorDefinition ): Promise<ShadowGenerator> {
-		const parameterDeclarations: ParameterDeclarations = {};
-		// define declarations here if needed in future
-		const parameterBag = definition as {} as ParameterBag;
-		const parameters = Parameter.parseFromDeclarations( parameterDeclarations, parameterBag );
-		const shadowGenerator = new ShadowGenerator( parameters['mapSize'], babylonLight );
-		for( const parameter in parameters ) {
-			if( parameter === 'mapSize' ) {
-				continue;
-			}
-			set( shadowGenerator, parameter, get( parameters, parameter ) );
-		}
-		return shadowGenerator;
-	};
-
-}

package/src/api/util/stringHelper.ts

@@ -1,26 +0,0 @@
-/**
- * Creates a random uuidv4.
- */
-const uuidv4 = function() {
-	// @ts-ignore
-	return ([1e7] + -1e3 + -4e3 + -8e3 + -1e11).replace( /[018]/g, c =>
-		(c ^ crypto.getRandomValues( new Uint8Array( 1 ) )[0] & 15 >> c / 4).toString( 16 )
-	);
-};
-
-/**
- * Converts a string from camel case to snake case.
- */
-const camelToSnakeCase = function( str: string ): string {
-	return str
-		.replace( /([A-Z])/g, " $1" )
-		.trim()
-		.split( ' ' )
-		.join('_')
-		.toLowerCase();
-};
-
-export {
-	uuidv4,
-	camelToSnakeCase,
-};