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

package/src/api/util/babylonHelper.ts

@@ -21,48 +21,47 @@ 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;
-}
+const getRootNode = function (node: Node): Node {
+  let _node = node;
+  while (_node.parent) {
+    _node = _node.parent;
+  }
+  return _node;
+};
 
 /**
  * @param nodes
  * @param predicate
  * @return Map<DottedPath, T>
  */
-const mapToDottedNodes = function <T>( nodes: Node[],
-                                       predicate?: ( node: Node ) => boolean ): Map<DottedPath, T> {
-	const map = new Map<DottedPath, T>();
-	const addNodes = function( _node: Node ) {
-		if( predicate && predicate( _node ) ) {
-			map.set( _node.metadata.dottedPath, _node as any );
-		}
-		_node.getChildren().forEach( child => {
-			addNodes( child );
-		} );
-	};
-	nodes.forEach( node => {
-		addNodes( node );
-	} );
-	return map;
+const mapToDottedNodes = function <T>(nodes: Node[], predicate?: (node: Node) => boolean): Map<DottedPath, T> {
+  const map = new Map<DottedPath, T>();
+  const addNodes = function (_node: Node) {
+    if (predicate && predicate(_node)) {
+      map.set(_node.metadata.dottedPath, _node as any);
+    }
+    _node.getChildren().forEach(child => {
+      addNodes(child);
+    });
+  };
+  nodes.forEach(node => {
+    addNodes(node);
+  });
+  return map;
 };
 
 /**
  * @param node
  * @return DottedPath
  */
-const getDottedPathForNode = function( node: Node ): DottedPath {
-	const dottedPath = DottedPath.create( node.name );
-	let _parent = node;
-	while( _parent.parent ) {
-		_parent = _parent.parent;
-		dottedPath.unshiftPart( _parent.name );
-	}
-	return dottedPath;
+const getDottedPathForNode = function (node: Node): DottedPath {
+  const dottedPath = DottedPath.create(node.name);
+  let _parent = node;
+  while (_parent.parent) {
+    _parent = _parent.parent;
+    dottedPath.unshiftPart(_parent.name);
+  }
+  return dottedPath;
 };
 
 /**
@@ -71,41 +70,43 @@ const getDottedPathForNode = function( node: Node ): DottedPath {
  * @param deep
  * @return TransformNode | null
  */
-const cloneTransformNode = function( node: TransformNode,
-                                     predicate?: ( node: TransformNode ) => boolean,
-                                     deep: boolean = true ): TransformNode | null {
-	if( predicate && !predicate( node ) ) {
-		return null;
-	}
-	const clone = node.clone( node.name, node.parent, true );
-	if( clone ) {
-		clone.metadata = cloneDeep( node.metadata );
-	}
-	if( deep ) {
-		const children = node.getChildTransformNodes( true );
-		children.forEach( child => {
-			const clonedChild = cloneTransformNode( child, predicate, deep );
-			if( clonedChild ) {
-				clonedChild.parent = clone;
-			}
-		} );
-	}
-	return clone;
+const cloneTransformNode = function (
+  node: TransformNode,
+  predicate?: (node: TransformNode) => boolean,
+  deep: boolean = true
+): TransformNode | null {
+  if (predicate && !predicate(node)) {
+    return null;
+  }
+  const clone = node.clone(node.name, node.parent, true);
+  if (clone) {
+    clone.metadata = cloneDeep(node.metadata);
+  }
+  if (deep) {
+    const children = node.getChildTransformNodes(true);
+    children.forEach(child => {
+      const clonedChild = cloneTransformNode(child, predicate, deep);
+      if (clonedChild) {
+        clonedChild.parent = clone;
+      }
+    });
+  }
+  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 ) as Nullable<Node>, true );
-	} else if( node instanceof Light ) {
-		clone = node.clone( node.name, cloneNodeWithParents( node.parent ) as Nullable<Node> );
-	} else if( node ) {
-		throw new Error( `Cloning of "${node?.constructor.name}" is not implemented (yet).` );
-	}
-	return clone;
+const cloneNodeWithParents = function (node: Node | null): Node | null {
+  let clone = null;
+  if (node instanceof TransformNode) {
+    clone = node.clone(node.name, cloneNodeWithParents(node.parent) as Nullable<Node>, true);
+  } else if (node instanceof Light) {
+    clone = node.clone(node.name, cloneNodeWithParents(node.parent) as Nullable<Node>);
+  } else if (node) {
+    throw new Error(`Cloning of "${node?.constructor.name}" is not implemented (yet).`);
+  }
+  return clone;
 };
 
 /**
@@ -114,21 +115,20 @@ const cloneNodeWithParents = function( node: Node | null ): Node | null {
  * @param prefix
  * @return TransformNode
  */
-const cloneTransformNodeMaterial = function( node: TransformNode,
-                                             prefix: DottedPathArgument = '',
-                                             deep: boolean = true ): TransformNode {
-	if( node instanceof AbstractMesh && node.material ) {
-		const _prefix = DottedPath.create( prefix ).addParts([
-			'node',
-			node.uniqueId.toString()
-		]);
-		node.material = node.material.clone( _prefix.path );
-	}
-	if( deep ) {
-		const children = node.getChildTransformNodes( true );
-		children.forEach( child => cloneTransformNodeMaterial( child, prefix, deep ) );
-	}
-	return node;
+const cloneTransformNodeMaterial = function (
+  node: TransformNode,
+  prefix: DottedPathArgument = '',
+  deep: boolean = true
+): TransformNode {
+  if (node instanceof AbstractMesh && node.material) {
+    const newMatName = DottedPath.create(prefix).addParts([node.material.name, 'clone', node.uniqueId.toString()]);
+    node.material = node.material.clone(newMatName.path);
+  }
+  if (deep) {
+    const children = node.getChildTransformNodes(true);
+    children.forEach(child => cloneTransformNodeMaterial(child, prefix, deep));
+  }
+  return node;
 };
 
 /**
@@ -136,12 +136,12 @@ const cloneTransformNodeMaterial = function( node: TransformNode,
  * @param deep
  * @param metadata
  */
-const injectNodeMetadata = function( node: Node, metadata: {}, deep: boolean = true ) {
-	node.metadata = merge( {}, node.metadata, metadata );
-	if( deep && node instanceof TransformNode ) {
-		const children = node.getChildTransformNodes( true );
-		children.forEach( child => injectNodeMetadata( child, metadata, deep ) );
-	}
+const injectNodeMetadata = function (node: Node, metadata: {}, deep: boolean = true) {
+  node.metadata = merge({}, node.metadata, metadata);
+  if (deep && node instanceof TransformNode) {
+    const children = node.getChildTransformNodes(true);
+    children.forEach(child => injectNodeMetadata(child, metadata, deep));
+  }
 };
 
 /**
@@ -150,69 +150,71 @@ const injectNodeMetadata = function( node: Node, metadata: {}, deep: boolean = t
  * @param callableParameters
  * @param deep
  */
-const assertTransformNode = function( node: TransformNode,
-                                      assertCallable: CallableFunction,
-                                      callableParameters: any[] = [],
-                                      deep: boolean = true ) {
-	assertCallable(node, ...callableParameters);
-	if( deep ) {
-		const children = node.getChildTransformNodes( true );
-		children.forEach( child => assertTransformNode( child, assertCallable, callableParameters, deep ) );
-	}
+const assertTransformNode = function (
+  node: TransformNode,
+  assertCallable: CallableFunction,
+  callableParameters: any[] = [],
+  deep: boolean = true
+) {
+  assertCallable(node, ...callableParameters);
+  if (deep) {
+    const children = node.getChildTransformNodes(true);
+    children.forEach(child => assertTransformNode(child, assertCallable, callableParameters, deep));
+  }
 };
 
 /**
  * @param node
  * @param deep
  */
-const activateTransformNode = function( node: TransformNode, deep: boolean = true ) {
-	node.setEnabled( true );
-	/*
+const activateTransformNode = function (node: TransformNode, deep: boolean = true) {
+  node.setEnabled(true);
+  /*
 	if( node instanceof AbstractMesh ) {
 		node.visibility = 1;
 		node.isPickable = true;
 	}
 	*/
-	if( deep ) {
-		node.getChildTransformNodes( true ).forEach( child => activateTransformNode( child, deep ) );
-	}
+  if (deep) {
+    node.getChildTransformNodes(true).forEach(child => activateTransformNode(child, deep));
+  }
 };
 
 /**
  * @param node
  * @param deep
  */
-const deactivateTransformNode = function( node: TransformNode, deep: boolean = true ) {
-	node.setEnabled( false );
-	/*
+const deactivateTransformNode = function (node: TransformNode, deep: boolean = true) {
+  node.setEnabled(false);
+  /*
 	if( node instanceof AbstractMesh ) {
 		node.visibility = 0;
 		node.isPickable = false;
 	}
 	*/
-	if( deep ) {
-		node.getChildTransformNodes( true ).forEach( child => deactivateTransformNode( child, deep ) );
-	}
+  if (deep) {
+    node.getChildTransformNodes(true).forEach(child => deactivateTransformNode(child, deep));
+  }
 };
 
 /**
  * @param node
  */
-const enableNodeWithParents = function( node: Node ) {
-	node.setEnabled( true );
-	if ( node.parent ) {
-		enableNodeWithParents( node.parent );
-	}
+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 );
-	}
+const disableNodeWithParents = function (node: Node) {
+  node.setEnabled(false);
+  if (node.parent) {
+    disableNodeWithParents(node.parent);
+  }
 };
 
 /**
@@ -220,33 +222,33 @@ const disableNodeWithParents = function( node: Node ) {
  * @param node
  * @param transformation
  */
-const transformTransformNode = function( node: TransformNode, transformation: TransformationDefinition ) {
-	// scaling
-	if( !has( node.metadata, 'scaling.initial' ) ) {
-		injectNodeMetadata( node, { 'scaling.initial': node.scaling }, false );
-	}
-	const initialScaling = get( node.metadata, 'scaling.initial' ) as Vector3;
-	node.scaling = initialScaling.multiply( transformation.scaling );
-	// position
-	if( !has( node.metadata, 'position.initial' ) ) {
-		injectNodeMetadata( node, { 'position.initial': node.absolutePosition.clone() }, false );
-	}
-	const initialPosition = get( node.metadata, 'position.initial' ) as Vector3;
-	node.setAbsolutePosition( initialPosition.add( transformation.position ).multiply( transformation.scaling ) );
-	// rotation
-	if( !has( node.metadata, 'rotation.initial' ) ) {
-		let rotationQuaternion = node.rotationQuaternion;
-		if( !rotationQuaternion ) {
-			rotationQuaternion = Quaternion.RotationYawPitchRoll( node.rotation.x, node.rotation.y, node.rotation.z );
-		}
-		injectNodeMetadata( node, { 'rotation.initial': rotationQuaternion.asArray() }, false );
-	}
-	const initialRotationQuaternion = Quaternion.FromArray( get( node.metadata, 'rotation.initial' ) as [] );
-	node.rotationQuaternion = initialRotationQuaternion;
-	node.rotateAround( Vector3.Zero(), Axis.X, transformation.rotation.x );
-	node.rotateAround( Vector3.Zero(), Axis.Y, transformation.rotation.y );
-	node.rotateAround( Vector3.Zero(), Axis.Z, transformation.rotation.z );
-	node.computeWorldMatrix( true );
+const transformTransformNode = function (node: TransformNode, transformation: TransformationDefinition) {
+  // scaling
+  if (!has(node.metadata, 'scaling.initial')) {
+    injectNodeMetadata(node, { 'scaling.initial': node.scaling }, false);
+  }
+  const initialScaling = get(node.metadata, 'scaling.initial') as Vector3;
+  node.scaling = initialScaling.multiply(transformation.scaling);
+  // position
+  if (!has(node.metadata, 'position.initial')) {
+    injectNodeMetadata(node, { 'position.initial': node.absolutePosition.clone() }, false);
+  }
+  const initialPosition = get(node.metadata, 'position.initial') as Vector3;
+  node.setAbsolutePosition(initialPosition.add(transformation.position).multiply(transformation.scaling));
+  // rotation
+  if (!has(node.metadata, 'rotation.initial')) {
+    let rotationQuaternion = node.rotationQuaternion;
+    if (!rotationQuaternion) {
+      rotationQuaternion = Quaternion.RotationYawPitchRoll(node.rotation.x, node.rotation.y, node.rotation.z);
+    }
+    injectNodeMetadata(node, { 'rotation.initial': rotationQuaternion.asArray() }, false);
+  }
+  const initialRotationQuaternion = Quaternion.FromArray(get(node.metadata, 'rotation.initial') as []);
+  node.rotationQuaternion = initialRotationQuaternion;
+  node.rotateAround(Vector3.Zero(), Axis.X, transformation.rotation.x);
+  node.rotateAround(Vector3.Zero(), Axis.Y, transformation.rotation.y);
+  node.rotateAround(Vector3.Zero(), Axis.Z, transformation.rotation.z);
+  node.computeWorldMatrix(true);
 };
 
 /**
@@ -254,43 +256,43 @@ const transformTransformNode = function( node: TransformNode, transformation: Tr
  * @param material
  * @param deep
  */
-const setMaterial = function( node: TransformNode, material: Material, deep: boolean = true ) {
-	if( node instanceof AbstractMesh ) {
-		node.material = material;
-	}
-	if( deep ) {
-		node.getChildTransformNodes( true ).forEach( child => setMaterial( child, material, deep ) );
-	}
+const setMaterial = function (node: TransformNode, material: Material, deep: boolean = true) {
+  if (node instanceof AbstractMesh) {
+    node.material = material;
+  }
+  if (deep) {
+    node.getChildTransformNodes(true).forEach(child => setMaterial(child, material, deep));
+  }
 };
 
 /**
  * !!! Warning !!!
  * This function is not public API. Whilst it can help solving certain problems, it only works reliably in well defined
  * situations and can cause unwanted side effects under some conditions. Use carefully at your own risk!
- * 
+ *
  * See https://combeenation.myjetbrains.com/youtrack/issue/CB-5906 for further details regarding this warning.
- * 
+ *
  * Set material of an instanced meshes source mesh.
  * Changes the material of all instanced meshes which have the same source mesh.
- * 
+ *
  * @param node
  * @param material
  * @param deep
- * 
+ *
  * @ignore
  */
-const setSourceNodeMaterial = function( node: TransformNode, material: Material, deep: boolean = true ) {
-	const warn = `	You're using "setSourceNodeMaterial" which is not public API.
+const setSourceNodeMaterial = function (node: TransformNode, material: Material, deep: boolean = true) {
+  const warn = `	You're using "setSourceNodeMaterial" which is not public API.
 	Whilst it can help solving certain problems, it only works reliably in well defined situations and can cause unwanted side effects under some conditions.
 	Use carefully at your own risk!`;
-	console.warn(`!!! Warning !!!\n${warn}`);
-	
-	if( node instanceof InstancedMesh ) {
-		node.sourceMesh.material = material;
-	}
-	if( deep ) {
-		node.getChildTransformNodes( true ).forEach( child => setSourceNodeMaterial( child, material, deep ) );
-	}
+  console.warn(`!!! Warning !!!\n${warn}`);
+
+  if (node instanceof InstancedMesh) {
+    node.sourceMesh.material = material;
+  }
+  if (deep) {
+    node.getChildTransformNodes(true).forEach(child => setSourceNodeMaterial(child, material, deep));
+  }
 };
 
 /**
@@ -298,23 +300,23 @@ const setSourceNodeMaterial = function( node: TransformNode, material: Material,
  * @param color
  * @param deep
  */
-const setMaterialColor = function( node: TransformNode, color: Color3, deep: boolean = true ) {
-	if( node instanceof AbstractMesh && node.material ) {
-		const materialCls = node.material.getClassName();
-		switch( materialCls ) {
-			case 'PBRMaterial':
-				(node.material as PBRMaterial).albedoColor = color.toLinearSpace();
-				break;
-			case 'StandardMaterial':
-				(node.material as StandardMaterial).diffuseColor = color;
-				break;
-			default:
-				throw new Error( `Setting color for material of instance "${materialCls}" not implemented (yet).` );
-		}
-	}
-	if( deep ) {
-		node.getChildTransformNodes( true ).forEach( child => setMaterialColor( child, color, deep ) );
-	}
+const setMaterialColor = function (node: TransformNode, color: Color3, deep: boolean = true) {
+  if (node instanceof AbstractMesh && node.material) {
+    const materialCls = node.material.getClassName();
+    switch (materialCls) {
+      case 'PBRMaterial':
+        (node.material as PBRMaterial).albedoColor = color.toLinearSpace();
+        break;
+      case 'StandardMaterial':
+        (node.material as StandardMaterial).diffuseColor = color;
+        break;
+      default:
+        throw new Error(`Setting color for material of instance "${materialCls}" not implemented (yet).`);
+    }
+  }
+  if (deep) {
+    node.getChildTransformNodes(true).forEach(child => setMaterialColor(child, color, deep));
+  }
 };
 
 /**
@@ -322,23 +324,23 @@ const setMaterialColor = function( node: TransformNode, color: Color3, deep: boo
  * @param texture
  * @param deep
  */
-const setMaterialTexture = function( node: TransformNode, texture: Texture, deep: boolean = true ) {
-	if( node instanceof AbstractMesh && node.material ) {
-		const materialCls = node.material.getClassName();
-		switch( materialCls ) {
-			case 'PBRMaterial':
-				(node.material as PBRMaterial).albedoTexture = texture;
-				break;
-			case 'StandardMaterial':
-				(node.material as StandardMaterial).diffuseTexture = texture;
-				break;
-			default:
-				throw new Error( `Setting texture for material of instance "${materialCls}" not implemented (yet).` );
-		}
-	}
-	if( deep ) {
-		node.getChildTransformNodes( true ).forEach( child => setMaterialTexture( child, texture, deep ) );
-	}
+const setMaterialTexture = function (node: TransformNode, texture: Texture, deep: boolean = true) {
+  if (node instanceof AbstractMesh && node.material) {
+    const materialCls = node.material.getClassName();
+    switch (materialCls) {
+      case 'PBRMaterial':
+        (node.material as PBRMaterial).albedoTexture = texture;
+        break;
+      case 'StandardMaterial':
+        (node.material as StandardMaterial).diffuseTexture = texture;
+        break;
+      default:
+        throw new Error(`Setting texture for material of instance "${materialCls}" not implemented (yet).`);
+    }
+  }
+  if (deep) {
+    node.getChildTransformNodes(true).forEach(child => setMaterialTexture(child, texture, deep));
+  }
 };
 
 /**
@@ -346,20 +348,20 @@ const setMaterialTexture = function( node: TransformNode, texture: Texture, deep
  * @param metallness
  * @param deep
  */
-const setMaterialMetallness = function( node: TransformNode, metallness: number, deep: boolean = true ) {
-	if( node instanceof AbstractMesh && node.material ) {
-		const materialCls = node.material.getClassName();
-		switch( materialCls ) {
-			case 'PBRMaterial':
-				(node.material as PBRMaterial).metallic = metallness;
-				break;
-			default:
-				throw new Error( `Setting metallness for material of instance "${materialCls}" not implemented (yet).` );
-		}
-	}
-	if( deep ) {
-		node.getChildTransformNodes( true ).forEach( child => setMaterialMetallness( child, metallness, deep ) );
-	}
+const setMaterialMetallness = function (node: TransformNode, metallness: number, deep: boolean = true) {
+  if (node instanceof AbstractMesh && node.material) {
+    const materialCls = node.material.getClassName();
+    switch (materialCls) {
+      case 'PBRMaterial':
+        (node.material as PBRMaterial).metallic = metallness;
+        break;
+      default:
+        throw new Error(`Setting metallness for material of instance "${materialCls}" not implemented (yet).`);
+    }
+  }
+  if (deep) {
+    node.getChildTransformNodes(true).forEach(child => setMaterialMetallness(child, metallness, deep));
+  }
 };
 
 /**
@@ -367,23 +369,23 @@ const setMaterialMetallness = function( node: TransformNode, metallness: number,
  * @param roughness
  * @param deep
  */
-const setMaterialRoughness = function( node: TransformNode, roughness: number, deep: boolean = true ) {
-	if( node instanceof AbstractMesh && node.material ) {
-		const materialCls = node.material.getClassName();
-		switch( materialCls ) {
-			case 'PBRMaterial':
-				(node.material as PBRMaterial).roughness = roughness;
-				break;
-			case 'StandardMaterial':
-				(node.material as StandardMaterial).roughness = roughness;
-				break;
-			default:
-				throw new Error( `Setting roughness for material of instance "${materialCls}" not implemented (yet).` );
-		}
-	}
-	if( deep ) {
-		node.getChildTransformNodes( true ).forEach( child => setMaterialRoughness( child, roughness, deep ) );
-	}
+const setMaterialRoughness = function (node: TransformNode, roughness: number, deep: boolean = true) {
+  if (node instanceof AbstractMesh && node.material) {
+    const materialCls = node.material.getClassName();
+    switch (materialCls) {
+      case 'PBRMaterial':
+        (node.material as PBRMaterial).roughness = roughness;
+        break;
+      case 'StandardMaterial':
+        (node.material as StandardMaterial).roughness = roughness;
+        break;
+      default:
+        throw new Error(`Setting roughness for material of instance "${materialCls}" not implemented (yet).`);
+    }
+  }
+  if (deep) {
+    node.getChildTransformNodes(true).forEach(child => setMaterialRoughness(child, roughness, deep));
+  }
 };
 
 /**
@@ -392,15 +394,13 @@ const setMaterialRoughness = function( node: TransformNode, roughness: number, d
  * @param color
  * @param deep
  */
-const addToHighlightLayer = function( layer: HighlightLayer, color: Color3, node: TransformNode, deep: boolean = true ) {
-	if( node instanceof AbstractMesh ) {
-		layer.addMesh( (node as Mesh), color );
-	}
-	if( deep ) {
-		node.getChildTransformNodes( true ).forEach(
-			child => addToHighlightLayer( layer, color, child, deep )
-		);
-	}
+const addToHighlightLayer = function (layer: HighlightLayer, color: Color3, node: TransformNode, deep: boolean = true) {
+  if (node instanceof AbstractMesh) {
+    layer.addMesh(node as Mesh, color);
+  }
+  if (deep) {
+    node.getChildTransformNodes(true).forEach(child => addToHighlightLayer(layer, color, child, deep));
+  }
 };
 
 /**
@@ -408,15 +408,13 @@ const addToHighlightLayer = function( layer: HighlightLayer, color: Color3, node
  * @param layer
  * @param deep
  */
-const removeFromHighlightLayer = function( layer: HighlightLayer, node: TransformNode, deep: boolean = true ) {
-	if( node instanceof AbstractMesh ) {
-		layer.removeMesh( (node as Mesh) );
-	}
-	if( deep ) {
-		node.getChildTransformNodes( true ).forEach(
-			child => removeFromHighlightLayer( layer, child, deep )
-		);
-	}
+const removeFromHighlightLayer = function (layer: HighlightLayer, node: TransformNode, deep: boolean = true) {
+  if (node instanceof AbstractMesh) {
+    layer.removeMesh(node as Mesh);
+  }
+  if (deep) {
+    node.getChildTransformNodes(true).forEach(child => removeFromHighlightLayer(layer, child, deep));
+  }
 };
 
 /**
@@ -424,15 +422,13 @@ const removeFromHighlightLayer = function( layer: HighlightLayer, node: Transfor
  * @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 )
-		);
-	}
+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));
+  }
 };
 
 /**
@@ -440,17 +436,15 @@ const setReceiveShadows = function( node: TransformNode, receiveShadows: boolean
  * @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 )
-		);
-	}
+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));
+  }
 };
 
 /**
@@ -458,15 +452,13 @@ const addToShadowGenerator = function( generator: ShadowGenerator, node: Transfo
  * @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 )
-		);
-	}
+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));
+  }
 };
 
 /**
@@ -475,60 +467,72 @@ const removeFromShadowGenerator = function( generator: ShadowGenerator, node: Tr
  * @param scene
  * @param canvas
  */
-const getClientRectFromMesh = function( mesh: AbstractMesh, scene: Scene, canvas: HTMLCanvasElement ): ClientRect {
-	// get bounding box of the mesh
-	const meshVectors = mesh.getBoundingInfo().boundingBox.vectors;
-	// get the matrix and viewport needed to project the vectors onto the screen
-	const worldMatrix = mesh.getWorldMatrix();
-	const transformMatrix = scene.getTransformMatrix();
-	const viewport = scene.activeCamera!.viewport;
-	// loop though all the vectors and project them against the current camera viewport to get a set of coordinates
-	const coordinates = meshVectors.map( vector => {
-		const projection = Vector3.Project( vector, worldMatrix, transformMatrix, viewport );
-		projection.x = projection.x * canvas.clientWidth;
-		projection.y = projection.y * canvas.clientHeight;
-		return projection;
-	} );
-	// get the min and max for all the coordinates so we can calculate the largest possible screen size
-	const maxX = Math.max.apply( Math, coordinates.map( o => o.x ) );
-	const minX = Math.min.apply( Math, coordinates.map( o => o.x ) );
-	const maxY = Math.max.apply( Math, coordinates.map( o => o.y ) );
-	const minY = Math.min.apply( Math, coordinates.map( o => o.y ) );
-	// return a ClientRect from this
-	return {
-		width: maxX - minX,
-		height: maxY - minY,
-		left: minX,
-		top: minY,
-		right: maxX,
-		bottom: maxY,
-	} as ClientRect;
+const getClientRectFromMesh = function (mesh: AbstractMesh, scene: Scene, canvas: HTMLCanvasElement): ClientRect {
+  // get bounding box of the mesh
+  const meshVectors = mesh.getBoundingInfo().boundingBox.vectors;
+  // get the matrix and viewport needed to project the vectors onto the screen
+  const worldMatrix = mesh.getWorldMatrix();
+  const transformMatrix = scene.getTransformMatrix();
+  const viewport = scene.activeCamera!.viewport;
+  // loop though all the vectors and project them against the current camera viewport to get a set of coordinates
+  const coordinates = meshVectors.map(vector => {
+    const projection = Vector3.Project(vector, worldMatrix, transformMatrix, viewport);
+    projection.x = projection.x * canvas.clientWidth;
+    projection.y = projection.y * canvas.clientHeight;
+    return projection;
+  });
+  // get the min and max for all the coordinates so we can calculate the largest possible screen size
+  const maxX = Math.max.apply(
+    Math,
+    coordinates.map(o => o.x)
+  );
+  const minX = Math.min.apply(
+    Math,
+    coordinates.map(o => o.x)
+  );
+  const maxY = Math.max.apply(
+    Math,
+    coordinates.map(o => o.y)
+  );
+  const minY = Math.min.apply(
+    Math,
+    coordinates.map(o => o.y)
+  );
+  // return a ClientRect from this
+  return {
+    width: maxX - minX,
+    height: maxY - minY,
+    left: minX,
+    top: minY,
+    right: maxX,
+    bottom: maxY,
+  } as ClientRect;
 };
 
 export {
-	getRootNode,
-	mapToDottedNodes,
-	getDottedPathForNode,
-	cloneTransformNode,
-	cloneNodeWithParents,
-	cloneTransformNodeMaterial,
-	injectNodeMetadata,
-	assertTransformNode,
-	activateTransformNode,
-	deactivateTransformNode,
-	enableNodeWithParents,
-	disableNodeWithParents,
-	transformTransformNode,
-	setMaterial,
-	setSourceNodeMaterial,
-	setMaterialColor,
-	setMaterialTexture,
-	setMaterialMetallness,
-	setMaterialRoughness,
-	addToHighlightLayer,
-	removeFromHighlightLayer,
-	setReceiveShadows,
-	addToShadowGenerator,
-	removeFromShadowGenerator,
-	getClientRectFromMesh
+  getRootNode,
+  mapToDottedNodes,
+  getDottedPathForNode,
+  cloneTransformNode,
+  cloneNodeWithParents,
+  cloneTransformNodeMaterial,
+  injectNodeMetadata,
+  assertTransformNode,
+  activateTransformNode,
+  deactivateTransformNode,
+  enableNodeWithParents,
+  disableNodeWithParents,
+  transformTransformNode,
+  setMaterial,
+  setSourceNodeMaterial,
+  setMaterialColor,
+  setMaterialTexture,
+  setMaterialMetallness,
+  setMaterialRoughness,
+  addToHighlightLayer,
+  removeFromHighlightLayer,
+  setReceiveShadows,
+  addToShadowGenerator,
+  removeFromShadowGenerator,
+  getClientRectFromMesh,
 };