@combeenation/3d-viewer 4.0.0-alpha8 → 4.0.0-beta3

package/src/api/internal/sceneSetup.ts

@@ -1,171 +1,180 @@
-import { Camera } from '@babylonjs/core/Cameras/camera';
+
 import { Engine } from '@babylonjs/core/Engines/engine';
-import '@babylonjs/core/Helpers/sceneHelpers';
 import '@babylonjs/core/Materials/Textures/Loaders/ddsTextureLoader';
-import { Color4 } from '@babylonjs/core/Maths/math.color';
+import '@babylonjs/core/Helpers/sceneHelpers';
+import { StandardMaterial } from '@babylonjs/core/Materials/standardMaterial';
+import { HDRCubeTexture } from '@babylonjs/core/Materials/Textures/hdrCubeTexture';
+import { Texture } from '@babylonjs/core/Materials/Textures/texture';
+import { Color3, Color4 } from '@babylonjs/core/Maths/math.color';
 import { Vector3 } from '@babylonjs/core/Maths/math.vector';
-import { GroundMesh } from '@babylonjs/core/Meshes/groundMesh';
 import { MeshBuilder } from '@babylonjs/core/Meshes/meshBuilder';
 import { DefaultRenderingPipeline } from '@babylonjs/core/PostProcesses/RenderPipeline/Pipelines/defaultRenderingPipeline';
 import { Scene } from '@babylonjs/core/scene';
-import { get, isEmpty, set } from 'lodash-es';
+import type { HemisphericLight } from '@babylonjs/core/Lights/hemisphericLight';
+import { Camera } from '@babylonjs/core/Cameras/camera';
+import { Light } from '@babylonjs/core/Lights/light';
 import { Parameter } from '../classes/parameter';
 
-/**
- * @param scene
- * @param name
- * @param definition
- */
-const processGround = async function( scene: Scene, name: string, definition: GroundDefinition ): Promise<Mesh | GroundMesh> {
-	return new Promise( resolve => {
-		const _resolve = ( ground: Mesh ) => {
-			if( definition.receiveShadows !== undefined ) {
-				ground.receiveShadows = definition.receiveShadows;
-			}
-			resolve( ground );
-		};
-		switch( definition.type ) {
-			case 'baked':
-				if( !definition.meshId ) {
-					throw new Error( `A baked ground must define a "meshId".` );
-				}
-				_resolve( scene.getMeshByID( definition.meshId ) as Mesh );
-				break;
-			case 'ground':
-				_resolve( MeshBuilder.CreateGround(
-					name,
-					definition,
-					scene
-				) );
-				break;
-			case 'heightmap':
-				if( !definition.url ) {
-					throw new Error( `A heightmap ground must define an "url".` );
-				}
-				definition.onReady = ( _ground: GroundMesh ) => {
-					_resolve( _ground );
-				};
-				MeshBuilder.CreateGroundFromHeightMap(
-					name,
-					definition.url,
-					definition,
-					scene,
-				);
-				break;
-			default:
-				throw new Error( `Ground of type "${definition.type}" not implemented (yet).` );
-		}
-	} );
+
+const defaultLightning = async function(scene: Scene) {
+	const defaultSetup: LightDefinition = {
+		type: 'hemispheric',
+	};
+
+	const defaultLight = await processLight(scene, 'default_light', defaultSetup) as HemisphericLight;
+	defaultLight.groundColor = Color3.Black();
+	defaultLight.diffuse = Color3.White();
+
+	return defaultLight;
+};
+
+
+const processLight = async function(scene: Scene, name: string, lightSetup: LightDefinition) {
+
+	let light: Light;
+
+	switch(lightSetup.type ) {
+		case 'hemispheric':
+			// @ts-ignore
+			const hemisphericLightModule = await import(/* webpackChunkName: "hemispheric-light" */ '@babylonjs/core/Lights/hemisphericLight');
+			light = new hemisphericLightModule.HemisphericLight( name, Vector3.Up(), scene);
+			break;
+		case 'point':
+			// @ts-ignore
+			const pointLightModule = await import(/* webpackChunkName: "point-light" */ '@babylonjs/core/Lights/pointLight');
+			light = new pointLightModule.PointLight( name, Vector3.Up(), scene);
+			break;
+	}
+
+	return light;
 };
 
-/**
- * @param scene
- */
-const defaultCamera = async function( scene: Scene ): Promise<Camera> {
-	return await processCamera( scene, 'default_camera', {
+
+const defaultCamera = async function(scene: Scene) {
+
+	const cameraSetup: CameraDefinition = {
 		type: 'arc',
 		active: true,
-	} );
+	};
+
+	const defaultCamera = await processCamera(scene, 'default_camera', cameraSetup);
+
+	return defaultCamera;
 };
 
-/**
- * @param scene
- * @param name
- * @param cameraSetup
- */
-const processCamera = async function( scene: Scene, name: string, cameraSetup: CameraDefinition ): Promise<Camera> {
+const processCamera = async function(scene: Scene, name: string, cameraSetup: CameraDefinition) {
+
 	let camera: Camera;
+
 	let target = Vector3.Zero();
-	if( cameraSetup.target ) {
-		target = Parameter.parseVector( cameraSetup.target );
+	if(cameraSetup.target) {
+		target = Parameter.parseVector(cameraSetup.target);
 	}
-	switch( cameraSetup.type ) {
+
+	switch(cameraSetup.type ) {
 		case 'arc':
 			// @ts-ignore
 			const arcCameraModule = await import(/* webpackChunkName: "arc-rotate-camera" */ '@babylonjs/core/Cameras/arcRotateCamera');
-			camera = new arcCameraModule.ArcRotateCamera( name, Math.PI / 4, Math.PI / 4, 2, target, scene );
+			camera = new arcCameraModule.ArcRotateCamera(name, Math.PI / 4, Math.PI / 4, 2, target, scene );
 			camera.metadata = {
 				alpha: Math.PI / 4,
 				beta: Math.PI / 4,
 				radius: 2
 			};
 			break;
+
 	}
-	if( cameraSetup.active ) {
+
+	if(cameraSetup.active) {
 		camera.attachControl( scene.getEngine().getRenderingCanvas()!, true );
 	}
+
 	if( cameraSetup.fov ) {
 		camera.fov = cameraSetup.fov;
 	}
+
 	camera.storeState();
 	return camera;
 };
 
-/**
- * @param engine
- * @param sceneJson
- */
-const sceneSetup = async function(engine: Engine, sceneJson: SceneJson): Promise<Scene> {
+const sceneSetup = async function(engine: Engine, sceneJson: SceneJson) {
 	const scene = new Scene( engine );
 	scene.clearColor = new Color4(0, 0, 0, 0);
-	// cameras
-	const cameras: Camera[] = [];
-	const cameraDefinitions = get( sceneJson.scene, 'cameras' ) as CameraDefinitions;
-	if( !isEmpty( cameraDefinitions ) ) {
-		for( let cameraName in cameraDefinitions ) {
-			cameras.push( await processCamera( scene, cameraName, cameraDefinitions[cameraName] ) );
-		}
+
+	let cameras: Camera[] = [];
+	//there is either no "cameras" or "cameras" is empty
+	if( ! sceneJson.scene.hasOwnProperty('cameras') || (sceneJson.scene.cameras && ! Object.keys(sceneJson.scene.cameras).length ) ) {
+		const camera = await defaultCamera(scene);
+
+		cameras.push(camera);
 	} else {
-		const camera = await defaultCamera( scene );
-		cameras.push( camera );
+		for(let camera in sceneJson.scene.cameras) {
+			cameras.push(await processCamera(scene, camera, sceneJson.scene.cameras[camera]));
+		}
 	}
-	// grounds
-	const groundDefinitions = get( sceneJson.scene, 'grounds' ) as GroundDefinitions;
-	if( !isEmpty( groundDefinitions ) ) {
-		for( const groundName in groundDefinitions ) {
-			await processGround( scene, groundName, groundDefinitions[groundName] );
+
+
+	//there is either no "lights" or "lights" is empty
+	if( ! sceneJson.scene.hasOwnProperty('lights') || (sceneJson.scene.lights && ! Object.keys(sceneJson.scene.lights).length ) ) {
+		// await defaultLightning(scene);
+	} else {
+		for(let light in sceneJson.scene.lights) {
+			await processLight(scene, light, sceneJson.scene.lights[light]);
 		}
 	}
+
+
 	// TODO: try to split this away from the default rendering pipeline to save module imports
 	// The "hdr" setting had negative effect on rendering in Safari. Everything looked a little "edgy". I'm not completely
 	// sure if disabling it comes with other negative side effects I don't see right now, so we should probably
 	// investigate this a little more in detail at some point.
 	const defaultPipeline = new DefaultRenderingPipeline( 'default-rendering-pipeline', false, scene );
+	
 	/* DISABLED: causes problems with Internet Explorer
 	defaultPipeline.imageProcessingEnabled = true;
 	*/
+
 	if( sceneJson.scene.globals.aa ) {
 		defaultPipeline.fxaaEnabled = true; //implicitly does FxaaPostProcess()
 	}
+	
 	// Set samples regardless of fxaa setting since we don't want to use fxaa but still increase the sample count
 	defaultPipeline.samples = 8;
+
 	if( sceneJson.scene.globals['camera-settings'] ) {
-		if( sceneJson.scene.globals['camera-settings']!.sharpen && sceneJson.scene.globals['camera-settings']!.sharpen.enabled ) {
+		if( sceneJson.scene.globals['camera-settings'].sharpen && sceneJson.scene.globals['camera-settings'].sharpen.enabled ) {
 			defaultPipeline.sharpenEnabled = true; //implicitly does SharpenPostProcess()
 			//defaultPipeline.sharpen.colorAmount = 1;
 			//defaultPipeline.sharpen.edgeAmount = 0;
 		}
-		if( sceneJson.scene.globals['camera-settings']!.bloom && sceneJson.scene.globals['camera-settings']!.bloom.enabled ) {
+
+		if( sceneJson.scene.globals['camera-settings'].bloom && sceneJson.scene.globals['camera-settings'].bloom.enabled ) {
 			defaultPipeline.bloomEnabled = true;
-			if( sceneJson.scene.globals['camera-settings']!.bloom.size ) {
-				defaultPipeline.bloomScale = sceneJson.scene.globals['camera-settings']!.bloom.size;
+
+			if( sceneJson.scene.globals['camera-settings'].bloom.size ) {
+				defaultPipeline.bloomScale = sceneJson.scene.globals['camera-settings'].bloom.size;
 			}
-			if( sceneJson.scene.globals['camera-settings']!.bloom.threshold ) {
-				defaultPipeline.bloomThreshold = sceneJson.scene.globals['camera-settings']!.bloom.threshold;
+
+			if( sceneJson.scene.globals['camera-settings'].bloom.threshold ) {
+				defaultPipeline.bloomThreshold = sceneJson.scene.globals['camera-settings'].bloom.threshold;
 			}
 		}
-		if( sceneJson.scene.globals['camera-settings']!.contrast ) {
-			scene.imageProcessingConfiguration.contrast = sceneJson.scene.globals['camera-settings']!.contrast;
+
+		if( sceneJson.scene.globals['camera-settings'].contrast ) {
+			scene.imageProcessingConfiguration.contrast = sceneJson.scene.globals['camera-settings'].contrast;
 		}
-		if( sceneJson.scene.globals['camera-settings']!.exposure ) {
-			scene.imageProcessingConfiguration.exposure = sceneJson.scene.globals['camera-settings']!.exposure;
+
+		if( sceneJson.scene.globals['camera-settings'].exposure ) {
+			scene.imageProcessingConfiguration.exposure = sceneJson.scene.globals['camera-settings'].exposure;
 		}
-		if( sceneJson.scene.globals['camera-settings']!.dof && sceneJson.scene.globals['camera-settings']!.dof.enabled ) {
+
+		if( sceneJson.scene.globals['camera-settings'].dof && sceneJson.scene.globals['camera-settings'].dof.enabled ) {
 			//@ts-ignore
 			const module = await import(/* webpackChunkName: "lens-rendering" */ './lensRendering');
-			new module.LensRenderingPipeline( 'lens-rendering', sceneJson.scene.globals['camera-settings']!.dof.settings, scene, 1.0, cameras );
+			new module.LensRenderingPipeline( 'lens-rendering', sceneJson.scene.globals['camera-settings'].dof!.settings, scene, 1.0, cameras );
 		}
 	}
+
 	// TODO: make this dynamic
 	/*
 	const texture = new HDRCubeTexture("/assets/small_cave_1k.hdr", scene, 256);
@@ -186,9 +195,10 @@ const sceneSetup = async function(engine: Engine, sceneJson: SceneJson): Promise
 	*/
 
 	// TODO: shadows don't work with HemishpericLight
+
 	return scene;
 };
 
 export {
 	sceneSetup
-};
+}

package/src/api/util/babylonHelper.ts

@@ -1,10 +1,7 @@
 import { HighlightLayer } from '@babylonjs/core/Layers/highlightLayer';
-import { Light } from '@babylonjs/core/Lights/light';
-import { ShadowGenerator } from '@babylonjs/core/Lights/Shadows/shadowGenerator';
 import { Material } from '@babylonjs/core/Materials/material';
 import { PBRMaterial } from '@babylonjs/core/Materials/PBR/pbrMaterial';
 import { StandardMaterial } from '@babylonjs/core/Materials/standardMaterial';
-import { Axis, Space } from '@babylonjs/core/Maths/math.axis';
 import { Color3 } from '@babylonjs/core/Maths/math.color';
 import { Vector3 } from '@babylonjs/core/Maths/math.vector';
 import { AbstractMesh } from '@babylonjs/core/Meshes/abstractMesh';
@@ -13,22 +10,9 @@ import { Mesh } from '@babylonjs/core/Meshes/mesh';
 import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
 import { Node } from '@babylonjs/core/node';
 import { Scene } from '@babylonjs/core/scene';
-import { Parameter } from 'api/classes/parameter';
-import { cloneDeep, get, merge } from 'lodash-es';
+import { cloneDeep, merge } from 'lodash-es';
 import { DottedPath } from '../classes/dottedPath';
 
-/**
- * @param node
- * @return Node
- */
-const getRootNode = function( node: Node ): Node {
-	let _node = node;
-	while( _node.parent ) {
-		_node = _node.parent;
-	}
-	return _node;
-}
-
 /**
  * @param nodes
  * @param predicate
@@ -55,17 +39,18 @@ const mapToDottedNodes = function <T>( nodes: Node[],
  * @param node
  * @return DottedPath
  */
-const getDottedPathForNode = function( node: Node ): DottedPath {
+const getDottedPathForTransformNode = function( node: TransformNode ): DottedPath {
 	const dottedPath = DottedPath.create( node.name );
 	let _parent = node;
 	while( _parent.parent ) {
-		_parent = _parent.parent;
+		_parent = _parent.parent as TransformNode;
 		dottedPath.unshiftPart( _parent.name );
 	}
 	return dottedPath;
 };
 
 /**
+ *
  * @param node
  * @param predicate
  * @param deep
@@ -93,21 +78,6 @@ const cloneTransformNode = function( node: TransformNode,
 	return clone;
 };
 
-/**
- * @param node
- */
-const cloneNodeWithParents = function( node: Node | null ): Node | null {
-	let clone = null;
-	if( node instanceof TransformNode ) {
-		clone = node.clone( node.name, cloneNodeWithParents( node.parent ), true );
-	} else if( node instanceof Light ) {
-		clone = node.clone( node.name, cloneNodeWithParents( node.parent ) );
-	} else if( node ) {
-		throw new Error( `Cloning of "${node?.constructor.name}" is not implemented (yet).` );
-	}
-	return clone;
-};
-
 /**
  * @param node
  * @param deep
@@ -136,11 +106,11 @@ const cloneTransformNodeMaterial = function( node: TransformNode,
  * @param deep
  * @param metadata
  */
-const injectNodeMetadata = function( node: Node, metadata: {}, deep: boolean = true ) {
+const injectTransformNodeMetadata = function( node: TransformNode, metadata: {}, deep: boolean = true ) {
 	node.metadata = merge( {}, node.metadata, metadata );
-	if( deep && node instanceof TransformNode ) {
+	if( deep ) {
 		const children = node.getChildTransformNodes( true );
-		children.forEach( child => injectNodeMetadata( child, metadata, deep ) );
+		children.forEach( child => injectTransformNodeMetadata( child, metadata, deep ) );
 	}
 };
 
@@ -195,61 +165,6 @@ const deactivateTransformNode = function( node: TransformNode, deep: boolean = t
 	}
 };
 
-/**
- * @param node
- */
-const enableNodeWithParents = function( node: Node ) {
-	node.setEnabled( true );
-	if ( node.parent ) {
-		enableNodeWithParents( node.parent );
-	}
-};
-
-/**
- * @param node
- */
-const disableNodeWithParents = function( node: Node ) {
-	node.setEnabled( false );
-	if ( node.parent ) {
-		disableNodeWithParents( node.parent );
-	}
-};
-
-/**
- * @param node
- * @param rotation
- * @param space
- */
-const rotateTransformNode = function( node: TransformNode, rotation: Vector3 ): TransformNode {
-	// remember absolute rotation and reset it before translating
-	if( !get( node.metadata, 'rotation' ) ) {
-		injectNodeMetadata( node, { rotation: node.rotation.clone() }, false);
-	}
-	node.rotation = node.metadata.rotation;
-	// rotate
-	node.rotate( Axis.X, rotation.x, Space.WORLD );
-	node.rotate( Axis.Y, rotation.y, Space.WORLD );
-	node.rotate( Axis.Z, rotation.z, Space.WORLD );
-	return node;
-};
-
-/**
- * @param node
- * @param distance
- */
-const moveTransformNode = function( node: TransformNode, distance: Vector3 ): TransformNode {
-	// remember absolute position and reset it before translating
-	if( !get( node.metadata, 'position' ) ) {
-		injectNodeMetadata( node, { position: node.absolutePosition.clone() }, false);
-	}
-	node.setAbsolutePosition( node.metadata.position );
-	// move
-	node.translate( Axis.X, distance.x, Space.WORLD );
-	node.translate( Axis.Y, distance.y, Space.WORLD );
-	node.translate( Axis.Z, distance.z, Space.WORLD );
-	return node;
-}
-
 /**
  * @param node
  * @param material
@@ -420,56 +335,6 @@ const removeFromHighlightLayer = function( layer: HighlightLayer, node: Transfor
 	}
 };
 
-/**
- * @param node
- * @param receiveShadows
- * @param deep
- */
-const setReceiveShadows = function( node: TransformNode, receiveShadows: boolean, deep: boolean = true ) {
-	if( node instanceof AbstractMesh ) {
-		node.receiveShadows = receiveShadows;
-	}
-	if( deep ) {
-		node.getChildTransformNodes( true ).forEach(
-			child => setReceiveShadows( child, receiveShadows, deep )
-		);
-	}
-};
-
-/**
- * @param node
- * @param generator
- * @param deep
- */
-const addToShadowGenerator = function( generator: ShadowGenerator, node: TransformNode, deep: boolean = true ) {
-	if( node instanceof AbstractMesh ) {
-		// We have to remove the node because there's no duplicate check in babylon
-		generator.removeShadowCaster( node, false );
-		generator.addShadowCaster( node, false );
-	}
-	if( deep ) {
-		node.getChildTransformNodes( true ).forEach(
-			child => addToShadowGenerator( generator, child, deep )
-		);
-	}
-};
-
-/**
- * @param node
- * @param generator
- * @param deep
- */
-const removeFromShadowGenerator = function( generator: ShadowGenerator, node: TransformNode, deep: boolean = true ) {
-	if( node instanceof AbstractMesh ) {
-		generator.removeShadowCaster( node, false );
-	}
-	if( deep ) {
-		node.getChildTransformNodes( true ).forEach(
-			child => removeFromShadowGenerator( generator, child, deep )
-		);
-	}
-};
-
 /**
  * https://forum.babylonjs.com/t/get-mesh-bounding-box-position-and-size-in-2d-screen-coordinates/1058/3
  * @param mesh
@@ -507,20 +372,14 @@ const getClientRectFromMesh = function( mesh: AbstractMesh, scene: Scene, canvas
 };
 
 export {
-	getRootNode,
 	mapToDottedNodes,
-	getDottedPathForNode,
+	getDottedPathForTransformNode,
 	cloneTransformNode,
-	cloneNodeWithParents,
 	cloneTransformNodeMaterial,
-	injectNodeMetadata,
+	injectTransformNodeMetadata,
 	assertTransformNode,
 	activateTransformNode,
 	deactivateTransformNode,
-	enableNodeWithParents,
-	disableNodeWithParents,
-	rotateTransformNode,
-	moveTransformNode,
 	setMaterial,
 	setSourceNodeMaterial,
 	setMaterialColor,
@@ -529,8 +388,5 @@ export {
 	setMaterialRoughness,
 	addToHighlightLayer,
 	removeFromHighlightLayer,
-	setReceiveShadows,
-	addToShadowGenerator,
-	removeFromShadowGenerator,
 	getClientRectFromMesh
 };

package/src/api/util/globalTypes.ts

@@ -8,7 +8,6 @@ type VariantInstance = import("../classes/variantInstance").VariantInstance;
  */
 type VariantElement = import("../classes/element").Element;
 type DottedPath = import("../classes/dottedPath").DottedPath;
-type ViewerLight = import("../classes/viewerLight").ViewerLight;
 
 // global accessible types imported from BabylonJS
 type Scene = import("@babylonjs/core/scene").Scene;
@@ -69,10 +68,6 @@ type Asset = {
 	fileName: string | undefined
 };
 
-type ElementDefinitions = {
-	[name: string]: ElementDefinition | string[]
-};
-
 type ElementDefinition = {
 	paths: PathDefinitions,
 	traceables?: TraceableDefinitions,
@@ -97,9 +92,9 @@ type StructureJson = {
 	glTF?: Asset | string,
 	parameterDeclaration?: ParameterDeclarations,
 	parameters?: ParameterBag,
-	elements?: ElementDefinitions,
-	lights?: LightDefinitions,
-	grounds?: GroundDefinitions,
+	elements?: {
+		[name: string]: ElementDefinition | string[]
+	},
 	/**
 	 * `variants` is a declarative description of 3D-model variations in the configurator. Each variant itself is a
 	 * {@link StructureJson} which must at least define a `name` in the key of the list and the properties `glTF` and
@@ -128,7 +123,7 @@ type StructureJson = {
 	 */
 	variants?: {
 		[id: string]: StructureJson,
-	},
+	}
 };
 
 type SceneJson = {
@@ -149,7 +144,8 @@ type SceneJson = {
 
 type SceneDefinition = {
 	globals: SceneGlobals,
-	cameras?: CameraDefinitions,
+	lights?: LightDefinitions,
+	cameras?: CameraDefinitions
 };
 
 type SceneGlobals = {
@@ -193,29 +189,12 @@ type SceneGlobals = {
 	}
 };
 
-/**
- * {@link Viewer.screenshot} internally uses Babylons [ScreenshotTools.CreateScreenshotUsingRenderTarget](https://doc.babylonjs.com/typedoc/classes/babylon.screenshottools#createscreenshotusingrendertarget). \
- * See this link for additional info about the properties.
- */
 type ScreenshotSettings = {
-	/** Defaults to canvas width & height */
 	size?: IScreenshotSize,
-	/**
-	 * Default `image/png`
-	 * 
-	 * **Info regarding JPEG:** \
-	 * Use mimeType `image/jpeg` (**not** `image/jpg`) when creating jpeg's. \
-	 * Also ensure that {@link Scene.clearColor | viewer.scene.clearColor} has an alpha value of `1` as jpeg's don't support
-	 * transparency. Otherwise background will always be black for jpeg's.
-	 */
 	mimeType?: string,
-	/** Default `1` */
 	samples?: number,
-	/** Default `false` */
 	antialiasing?: boolean,
-	/** Default `screenshot.png` */
 	fileName?: string,
-	/** Default `false` */
 	renderSprites?: boolean
 };
 
@@ -231,40 +210,11 @@ type AutofocusSettings = {
 };
 
 type LightDefinitions = {
-	[name: string]: LightDefinition | string
+	[light: string]: LightDefinition
 };
 
 type LightDefinition = {
-	type: 'baked' | 'hemispheric' | 'point' | 'directional' | 'spot',
-	path?: string,
-	shadowGenerator?: ShadowGeneratorDefinition
-};
-
-type ShadowGeneratorDefinition = {
-	mapSize: number
-	[others: string]: any,
-	/**
-	 * Further properties like `usePoissonSampling` are set directly on the ShadowGenerator object.
-	 * [Shadows](https://doc.babylonjs.com/divingDeeper/lights/shadows)
-	 */
-};
-
-type GroundDefinitions = {
-	[ground: string]: GroundDefinition
-};
-
-type GroundDefinition = {
-	type: 'baked' | 'ground' | 'heightmap',
-	meshId?: string,
-	url?: string,
-	width?: number,
-	height?: number,
-	subdivisions?: number,
-	receiveShadows?: boolean,
-	minHeight?: number,
-	maxHeight?: number,
-	alphaFilter?: number,
-	onReady?: any
+	type: 'hemispheric' | 'point'
 };
 
 type CameraDefinitions = {
@@ -280,6 +230,10 @@ type CameraDefinition = {
 	/**
 	 * `arc` is a default camera position where the 3D-model is the center and the camera rotates around the 3D-model.
 	 * More Information about `arc` in [ArcRotateCamera](https://doc.babylonjs.com/typedoc/classes/babylon.arcrotatecamera).
+	 * 
+	 * NOTE: While "baked" camera definitions from a GLB or babylon file can currently not be instatiated within the `Specification`, it's still possible to use them in the viewer.\
+	 * For the moment all camera definitions inside these files are automatically added to the scene and can be actived using the {@link switchCamera} function.\
+	 * The `newCamera` input has to match the name of the camera node inside the GLB/babylon file.
 	 */
 	type: 'arc'
 	/**
@@ -304,8 +258,7 @@ type ParameterDeclarations = {
 };
 
 type ParameterDeclaration = {
-	type: 'string' | 'boolean' | 'number' | 'color' | 'select' | 'vector' | 'csl',
-	parser?: any,
+	type: 'string' | 'boolean' | 'number' | 'color' | 'select' | 'vector',
 	options?: ParameterValue[]
 };
 
@@ -315,10 +268,6 @@ type ParameterBag = {
 	[name: string]: ParameterValue
 };
 
-type ParsedParameterBag = {
-	[name: string]: any
-};
-
 type DottedPathArgument = string | string[] | DottedPath;
 
 type ParameterObserver = (