@shapediver/viewer.rendering-engine.light-engine 2.12.8 → 3.0.1

package/src/implementation/LightEngine.ts

@@ -1,22 +1,37 @@
-import { vec3 } from 'gl-matrix'
-import { Converter, UuidGenerator, SettingsEngine, StateEngine } from '@shapediver/viewer.shared.services'
-
-import { AmbientLight } from './types/AmbientLight'
-import { DirectionalLight } from './types/DirectionalLight'
-import { HemisphereLight } from './types/HemisphereLight'
-import { PointLight } from './types/PointLight'
-import { SpotLight } from './types/SpotLight'
-import { LightScene } from './LightScene'
-import { AbstractLight } from './AbstractLight'
-import { ILightEngine } from '../interface/ILightEngine'
-import { ILight, LIGHT_TYPE } from '../interface/ILight'
-import { ILightScene } from '../interface/ILightScene'
-import { IAmbientLightPropertiesV3, IDirectionalLightPropertiesV3, IHemisphereLightPropertiesV3, ILightSceneSettingsV3, IPointLightPropertiesV3, ISpotLightPropertiesV3 } from '@shapediver/viewer.settings'
-import { ITree, ITreeNode, Tree, TreeNode } from '@shapediver/viewer.shared.node-tree'
-import { IRenderingEngine } from '@shapediver/viewer.rendering-engine.rendering-engine'
+import { AbstractLight } from './AbstractLight';
+import { AmbientLight } from './types/AmbientLight';
+import {
+    Converter,
+    SettingsEngine,
+    UuidGenerator
+} from '@shapediver/viewer.shared.services';
+import { DirectionalLight } from './types/DirectionalLight';
+import { HemisphereLight } from './types/HemisphereLight';
+import {
+    IAmbientLightProperties,
+    IDirectionalLightProperties,
+    IHemisphereLightProperties,
+    ILightSceneSettings,
+    IPointLightProperties,
+    ISpotLightProperties
+} from '@shapediver/viewer.settings';
+import { LIGHT_TYPE } from '../interface/ILight';
+import { ILightEngine } from '../interface/ILightEngine';
+import { ILightScene } from '../interface/ILightScene';
+import { IRenderingEngine } from '@shapediver/viewer.rendering-engine.rendering-engine';
+import {
+    ITree,
+    ITreeNode,
+    Tree,
+    TreeNode
+} from '@shapediver/viewer.shared.node-tree';
+import { LightScene } from './LightScene';
+import { PointLight } from './types/PointLight';
+import { SpotLight } from './types/SpotLight';
+import { vec3 } from 'gl-matrix';
 
 export class LightEngine implements ILightEngine {
-    // #region Properties (6)
+    // #region Properties (7)
 
     private readonly _converter: Converter = Converter.instance;
     private readonly _lightNode: ITreeNode = new TreeNode('lights');
@@ -27,7 +42,7 @@ export class LightEngine implements ILightEngine {
     private _lightScenes: { [key: string]: LightScene; } = {};
     private _update?: () => void;
 
-    // #endregion Properties (6)
+    // #endregion Properties (7)
 
     // #region Constructors (1)
 
@@ -38,7 +53,7 @@ export class LightEngine implements ILightEngine {
 
     // #endregion Constructors (1)
 
-    // #region Public Accessors (2)
+    // #region Public Getters And Setters (4)
 
     public get lightScene(): LightScene | null {
         return this._lightScene;
@@ -58,28 +73,28 @@ export class LightEngine implements ILightEngine {
         this._update = value;
     }
 
-    // #endregion Public Accessors (2)
+    // #endregion Public Getters And Setters (4)
 
     // #region Public Methods (6)
 
     public applySettings(settingsEngine: SettingsEngine): void {
         this._lightScenes = {};
 
-        for (let lightSceneId in settingsEngine.light.lightScenes) {
+        for (const lightSceneId in settingsEngine.light.lightScenes) {
             const lightSceneUUID = this._uuidGenerator.validate(lightSceneId) ? lightSceneId : this._uuidGenerator.create();
             const lightSceneName = settingsEngine.light.lightScenes[lightSceneId].name ? settingsEngine.light.lightScenes[lightSceneId].name : lightSceneId;
-            const ls = new LightScene(this._renderingEngine, {id: lightSceneUUID, name: lightSceneName});
-            for (let lightId in settingsEngine.light.lightScenes[lightSceneId].lights) {
+            const ls = new LightScene(this._renderingEngine, { id: lightSceneUUID, name: lightSceneName });
+            for (const lightId in settingsEngine.light.lightScenes[lightSceneId].lights) {
                 const lightUUID = this._uuidGenerator.validate(lightId) ? lightId : this._uuidGenerator.create();
                 const light = settingsEngine.light.lightScenes[lightSceneId].lights[lightId];
                 let l: AbstractLight;
                 switch (light.type) {
                     case LIGHT_TYPE.DIRECTIONAL:
                         l = new DirectionalLight({
-                            color: this._converter.toHexColor((<IDirectionalLightPropertiesV3>light.properties).color), 
-                            intensity: (<IDirectionalLightPropertiesV3>light.properties).intensity, 
-                            direction: this._converter.toVec3((<IDirectionalLightPropertiesV3>light.properties).direction), 
-                            castShadow: (<IDirectionalLightPropertiesV3>light.properties).castShadow, 
+                            color: this._converter.toHexColor((<IDirectionalLightProperties>light.properties).color),
+                            intensity: (<IDirectionalLightProperties>light.properties).intensity,
+                            direction: this._converter.toVec3((<IDirectionalLightProperties>light.properties).direction),
+                            castShadow: (<IDirectionalLightProperties>light.properties).castShadow,
                             name: light.name ? light.name : lightId,
                             order: light.order,
                             id: lightUUID
@@ -87,9 +102,9 @@ export class LightEngine implements ILightEngine {
                         break;
                     case LIGHT_TYPE.HEMISPHERE:
                         l = new HemisphereLight({
-                            color: this._converter.toHexColor((<IHemisphereLightPropertiesV3>light.properties).skyColor), 
-                            intensity: (<IHemisphereLightPropertiesV3>light.properties).intensity, 
-                            groundColor: this._converter.toHexColor((<IHemisphereLightPropertiesV3>light.properties).groundColor), 
+                            color: this._converter.toHexColor((<IHemisphereLightProperties>light.properties).skyColor),
+                            intensity: (<IHemisphereLightProperties>light.properties).intensity,
+                            groundColor: this._converter.toHexColor((<IHemisphereLightProperties>light.properties).groundColor),
                             name: light.name ? light.name : lightId,
                             order: light.order,
                             id: lightUUID
@@ -97,11 +112,11 @@ export class LightEngine implements ILightEngine {
                         break;
                     case LIGHT_TYPE.POINT:
                         l = new PointLight({
-                            color: this._converter.toHexColor((<IPointLightPropertiesV3>light.properties).color), 
-                            intensity: (<IPointLightPropertiesV3>light.properties).intensity, 
-                            position: this._converter.toVec3((<IPointLightPropertiesV3>light.properties).position), 
-                            distance: (<IPointLightPropertiesV3>light.properties).distance, 
-                            decay: (<IPointLightPropertiesV3>light.properties).decay, 
+                            color: this._converter.toHexColor((<IPointLightProperties>light.properties).color),
+                            intensity: (<IPointLightProperties>light.properties).intensity,
+                            position: this._converter.toVec3((<IPointLightProperties>light.properties).position),
+                            distance: (<IPointLightProperties>light.properties).distance,
+                            decay: (<IPointLightProperties>light.properties).decay,
                             name: light.name ? light.name : lightId,
                             order: light.order,
                             id: lightUUID
@@ -109,14 +124,14 @@ export class LightEngine implements ILightEngine {
                         break;
                     case LIGHT_TYPE.SPOT:
                         l = new SpotLight({
-                            color: this._converter.toHexColor((<ISpotLightPropertiesV3>light.properties).color), 
-                            intensity: (<ISpotLightPropertiesV3>light.properties).intensity, 
-                            position: this._converter.toVec3((<ISpotLightPropertiesV3>light.properties).position), 
-                            target: this._converter.toVec3((<ISpotLightPropertiesV3>light.properties).target), 
-                            distance: (<ISpotLightPropertiesV3>light.properties).distance, 
-                            decay: (<ISpotLightPropertiesV3>light.properties).decay, 
-                            angle: (<ISpotLightPropertiesV3>light.properties).angle, 
-                            penumbra: (<ISpotLightPropertiesV3>light.properties).penumbra, 
+                            color: this._converter.toHexColor((<ISpotLightProperties>light.properties).color),
+                            intensity: (<ISpotLightProperties>light.properties).intensity,
+                            position: this._converter.toVec3((<ISpotLightProperties>light.properties).position),
+                            target: this._converter.toVec3((<ISpotLightProperties>light.properties).target),
+                            distance: (<ISpotLightProperties>light.properties).distance,
+                            decay: (<ISpotLightProperties>light.properties).decay,
+                            angle: (<ISpotLightProperties>light.properties).angle,
+                            penumbra: (<ISpotLightProperties>light.properties).penumbra,
                             name: light.name ? light.name : lightId,
                             order: light.order,
                             id: lightUUID
@@ -125,8 +140,8 @@ export class LightEngine implements ILightEngine {
                     case LIGHT_TYPE.AMBIENT:
                     default:
                         l = new AmbientLight({
-                            color: this._converter.toHexColor((<IAmbientLightPropertiesV3>light.properties).color), 
-                            intensity: (<IAmbientLightPropertiesV3>light.properties).intensity, 
+                            color: this._converter.toHexColor((<IAmbientLightProperties>light.properties).color),
+                            intensity: (<IAmbientLightProperties>light.properties).intensity,
                             name: light.name ? light.name : lightId,
                             order: light.order,
                             id: lightUUID
@@ -138,41 +153,41 @@ export class LightEngine implements ILightEngine {
         }
 
         // there is a light scene but no id is saved (old viewer)
-        if(settingsEngine.light.lightSceneId === undefined && Object.values(settingsEngine.light.lightScenes).length > 0) {
+        if (settingsEngine.light.lightSceneId === undefined && Object.values(settingsEngine.light.lightScenes).length > 0) {
             const res = this.assignLightScene(Object.keys(settingsEngine.light.lightScenes)[0]);
-            if(res === false){
+            if (res === false) {
                 const ls = <LightScene>this.createLightScene({ name: settingsEngine.light.lightSceneId === 'default' ? 'default' : 'standard' });
-                ls.addLight(new AmbientLight({color: '#ffffff', intensity: 0.5, name: 'ambient0'}));
-                ls.addLight(new DirectionalLight({color: '#ffffff', intensity: 0.75, direction: vec3.fromValues(.5774, -.5774, .5774), castShadow: true, name: 'directional0'}));
-                ls.addLight(new DirectionalLight({color: '#ffffff', intensity: 0.35, direction: vec3.fromValues(.25, -1, 1), castShadow: false, name: 'directional1'}));
+                ls.addLight(new AmbientLight({ color: '#ffffff', intensity: 0.5, name: 'ambient0' }));
+                ls.addLight(new DirectionalLight({ color: '#ffffff', intensity: 0.75, direction: vec3.fromValues(.5774, -.5774, .5774), castShadow: true, name: 'directional0' }));
+                ls.addLight(new DirectionalLight({ color: '#ffffff', intensity: 0.35, direction: vec3.fromValues(.25, -1, 1), castShadow: false, name: 'directional1' }));
                 this._lightScenes[ls.id] = ls;
             }
         } // there is no standard light scene in the light scenes, but a light scene name is specified (old viewer)
         else if (settingsEngine.light.lightSceneId) {
             const res = this.assignLightScene(settingsEngine.light.lightSceneId);
-            if(res === false){
+            if (res === false) {
                 const ls = <LightScene>this.createLightScene({ name: settingsEngine.light.lightSceneId === 'default' ? 'default' : 'standard' });
-                ls.addLight(new AmbientLight({color: '#ffffff', intensity: 0.5, name: 'ambient0'}));
-                ls.addLight(new DirectionalLight({color: '#ffffff', intensity: 0.75, direction: vec3.fromValues(.5774, -.5774, .5774), castShadow: true, name: 'directional0'}));
-                ls.addLight(new DirectionalLight({color: '#ffffff', intensity: 0.35, direction: vec3.fromValues(.25, -1, 1), castShadow: false, name: 'directional1'}));
+                ls.addLight(new AmbientLight({ color: '#ffffff', intensity: 0.5, name: 'ambient0' }));
+                ls.addLight(new DirectionalLight({ color: '#ffffff', intensity: 0.75, direction: vec3.fromValues(.5774, -.5774, .5774), castShadow: true, name: 'directional0' }));
+                ls.addLight(new DirectionalLight({ color: '#ffffff', intensity: 0.35, direction: vec3.fromValues(.25, -1, 1), castShadow: false, name: 'directional1' }));
                 this._lightScenes[ls.id] = ls;
             }
-        }  
+        }
         // this can only be the case if the settings were completely empty, therefore we assign the new light scene
-        else if(JSON.stringify(settingsEngine.settingsJson) == JSON.stringify({})) {    
+        else if (JSON.stringify(settingsEngine.settingsJson) == JSON.stringify({})) {
             const ls = <LightScene>this.createLightScene({ name: 'standard', standard: true });
             this._lightScenes[ls.id] = ls;
         }
 
-        if(this._update) this._update();
+        if (this._update) this._update();
     }
 
     public assignLightScene(id: string): boolean {
         if (!this._lightScenes[id]) {
-            for(let lightSceneId in this._lightScenes) {
+            for (const lightSceneId in this._lightScenes) {
                 const lightScene = this._lightScenes[lightSceneId];
                 const lightSceneName = lightScene.name || lightSceneId;
-                if(lightSceneName === id) {
+                if (lightSceneName === id) {
                     const res = this.assignLightScene(lightSceneId);
                     return res;
                 }
@@ -180,11 +195,11 @@ export class LightEngine implements ILightEngine {
             return false;
         }
         this._lightScene = this._lightScenes[id];
-        while(this._lightNode.children.length > 0)
+        while (this._lightNode.children.length > 0)
             this._lightNode.removeChild(this._lightNode.children[0]);
         this._lightNode.addChild(this._lightScene!.node);
         this._lightNode.updateVersion();
-        
+
         return true;
     }
 
@@ -192,30 +207,30 @@ export class LightEngine implements ILightEngine {
         this._tree.root.removeChild(this._lightNode);
     }
 
-    public createLightScene(properties: {name?: string, standard?: boolean}): ILightScene {
+    public createLightScene(properties: { name?: string, standard?: boolean }): ILightScene {
         const lightSceneId = this._uuidGenerator.create();
-        const lightScene = new LightScene(this._renderingEngine, {id: lightSceneId, name: properties.name});
+        const lightScene = new LightScene(this._renderingEngine, { id: lightSceneId, name: properties.name });
         if (properties.standard === true) {
-            lightScene.addLight(new DirectionalLight({color: '#ffffff', intensity: 2.5, direction: vec3.fromValues(.5774, -.5774, .5774), castShadow: true, name: 'directional0'}));
-            lightScene.addLight(new AmbientLight({color: '#ffffff', intensity: 0.3, name: 'ambient0'}));
+            lightScene.addLight(new DirectionalLight({ color: '#ffffff', intensity: 2.5, direction: vec3.fromValues(.5774, -.5774, .5774), castShadow: true, name: 'directional0' }));
+            lightScene.addLight(new AmbientLight({ color: '#ffffff', intensity: 0.3, name: 'ambient0' }));
         }
         this._lightScenes[lightSceneId] = lightScene;
         this._lightScene = lightScene;
-        while(this._lightNode.children.length > 0)
+        while (this._lightNode.children.length > 0)
             this._lightNode.removeChild(this._lightNode.children[0]);
-        this._lightNode.addChild(this._lightScene!.node)
+        this._lightNode.addChild(this._lightScene!.node);
         this._lightNode.updateVersion();
 
-        if(this._update) this._update();
+        if (this._update) this._update();
         return lightScene;
     }
 
     public removeLightScene(id: string): boolean {
         if (!this._lightScenes[id]) {
-            for(let lightSceneId in this._lightScenes) {
+            for (const lightSceneId in this._lightScenes) {
                 const lightScene = this._lightScenes[lightSceneId];
                 const lightSceneName = lightScene.name || lightSceneId;
-                if(lightSceneName === id) {
+                if (lightSceneName === id) {
                     const res = this.removeLightScene(lightSceneId);
                     return res;
                 }
@@ -223,7 +238,7 @@ export class LightEngine implements ILightEngine {
             return false;
         }
 
-        if(this._lightScene && this._lightScene.id === id) {
+        if (this._lightScene && this._lightScene.id === id) {
             (<any>this._lightScene) = undefined;
 
             while (this._lightNode.children.length > 0)
@@ -238,18 +253,18 @@ export class LightEngine implements ILightEngine {
 
     public saveSettings(settingsEngine: SettingsEngine) {
         settingsEngine.light.lightSceneId = this.lightScene ? this.lightScene.id : undefined;
-        
-        const converted: ILightSceneSettingsV3 = {};
-        for(let lightSceneId in this._lightScenes) {
+
+        const converted: ILightSceneSettings = {};
+        for (const lightSceneId in this._lightScenes) {
             const lightScene = this._lightScenes[lightSceneId];
             const lightSceneName = lightScene.name || lightSceneId;
             converted[lightSceneId] = {
                 name: lightSceneName,
                 lights: {}
             };
-            for(let lightId in lightScene.lights) {
+            for (const lightId in lightScene.lights) {
                 const light = lightScene.lights[lightId];
-                
+
                 let properties;
                 switch (light.type) {
                     case LIGHT_TYPE.DIRECTIONAL:
@@ -260,14 +275,14 @@ export class LightEngine implements ILightEngine {
                             castShadow: (<DirectionalLight>light).castShadow,
                             shadowMapResolution: (<DirectionalLight>light).shadowMapResolution,
                             shadowMapBias: (<DirectionalLight>light).shadowMapBias
-                        }
+                        };
                         break;
                     case LIGHT_TYPE.HEMISPHERE:
                         properties = {
                             skyColor: this._converter.toHexColor(light.color),
                             intensity: light.intensity,
                             groundColor: this._converter.toHexColor((<HemisphereLight>light).groundColor)
-                        }
+                        };
                         break;
                     case LIGHT_TYPE.POINT:
                         properties = {
@@ -276,7 +291,7 @@ export class LightEngine implements ILightEngine {
                             position: { x: (<PointLight>light).position[0], y: (<PointLight>light).position[1], z: (<PointLight>light).position[2] },
                             distance: (<PointLight>light).distance,
                             decay: (<PointLight>light).decay
-                        }
+                        };
                         break;
                     case LIGHT_TYPE.SPOT:
                         properties = {
@@ -288,21 +303,21 @@ export class LightEngine implements ILightEngine {
                             decay: (<SpotLight>light).decay,
                             angle: (<SpotLight>light).angle,
                             penumbra: (<SpotLight>light).penumbra
-                        }
+                        };
                         break;
                     case LIGHT_TYPE.AMBIENT:
                     default:
                         properties = {
                             color: this._converter.toHexColor(light.color),
                             intensity: light.intensity
-                        }
+                        };
                 }
                 converted[lightSceneId].lights[lightId] = {
                     name: light.name,
                     type: light.type,
                     properties
-                }
-                if(light.order !== undefined)
+                };
+                if (light.order !== undefined)
                     converted[lightSceneId].lights[lightId].order = light.order;
             }
         }

package/src/implementation/types/AmbientLight.ts

@@ -1,17 +1,9 @@
-import { ITreeNodeData } from '@shapediver/viewer.shared.node-tree'
+import { AbstractLight } from '../AbstractLight';
 import { Color } from '@shapediver/viewer.shared.types';
-
-import { LIGHT_TYPE } from '../../interface/ILight'
 import { IAmbientLight } from '../../interface/types/IAmbientLight';
-import { AbstractLight } from '../AbstractLight'
+import { LIGHT_TYPE } from '../../interface/ILight';
 
 export class AmbientLight extends AbstractLight implements IAmbientLight {
-    // #region Properties (1)
-
-    #threeJsObject: { [key: string]: THREE.AmbientLight } = {};
-
-    // #endregion Properties (1)
-
     // #region Constructors (1)
 
     constructor(properties: {
@@ -23,8 +15,8 @@ export class AmbientLight extends AbstractLight implements IAmbientLight {
         version?: string
     }) {
         super({
-            color: properties.color || '#ffffff', 
-            intensity: properties.intensity !== undefined ? properties.intensity : 1, 
+            color: properties.color || '#ffffff',
+            intensity: properties.intensity !== undefined ? properties.intensity : 1,
             type: LIGHT_TYPE.AMBIENT,
             name: properties.name,
             order: properties.order,
@@ -35,20 +27,12 @@ export class AmbientLight extends AbstractLight implements IAmbientLight {
 
     // #endregion Constructors (1)
 
-    // #region Public Accessors (1)
-
-    public get threeJsObject(): { [key: string]: THREE.AmbientLight } {
-        return this.#threeJsObject;
-    }
-
-    // #endregion Public Accessors (1)
-
     // #region Public Methods (1)
 
     public clone(): IAmbientLight {
         return new AmbientLight({
-            color: this.color || '#ffffff', 
-            intensity: this.intensity || 0.5, 
+            color: this.color || '#ffffff',
+            intensity: this.intensity || 0.5,
             name: this.name,
             order: this.order,
             id: this.id,

package/src/implementation/types/DirectionalLight.ts

@@ -1,10 +1,8 @@
-import { ITreeNodeData } from '@shapediver/viewer.shared.node-tree'
-import { vec3 } from 'gl-matrix'
+import { AbstractLight } from '../AbstractLight';
 import { Color } from '@shapediver/viewer.shared.types';
-
-import { LIGHT_TYPE } from '../../interface/ILight'
 import { IDirectionalLight } from '../../interface/types/IDirectionalLight';
-import { AbstractLight } from '../AbstractLight'
+import { LIGHT_TYPE } from '../../interface/ILight';
+import { vec3 } from 'gl-matrix';
 
 export class DirectionalLight extends AbstractLight implements IDirectionalLight {
     // #region Properties (4)
@@ -13,7 +11,6 @@ export class DirectionalLight extends AbstractLight implements IDirectionalLight
     #direction: vec3 = vec3.fromValues(-1, 0, 1);
     #shadowMapBias: number = -0.003;
     #shadowMapResolution: number = 1024;
-    #threeJsObject: { [key: string]: THREE.DirectionalLight } = {};
 
     // #endregion Properties (4)
 
@@ -32,8 +29,8 @@ export class DirectionalLight extends AbstractLight implements IDirectionalLight
         version?: string
     }) {
         super({
-            color: properties.color || '#ffffff', 
-            intensity: properties.intensity !== undefined ? properties.intensity : 1, 
+            color: properties.color || '#ffffff',
+            intensity: properties.intensity !== undefined ? properties.intensity : 1,
             type: LIGHT_TYPE.DIRECTIONAL,
             name: properties.name,
             order: properties.order,
@@ -41,15 +38,15 @@ export class DirectionalLight extends AbstractLight implements IDirectionalLight
             version: properties.version
         });
 
-        if(properties.direction) this.#direction = properties.direction;
-        if(properties.castShadow !== undefined) this.#castShadow = properties.castShadow;
-        if(properties.shadowMapResolution) this.#shadowMapResolution = properties.shadowMapResolution;
-        if(properties.shadowMapBias) this.#shadowMapBias = properties.shadowMapBias;
+        if (properties.direction) this.#direction = properties.direction;
+        if (properties.castShadow !== undefined) this.#castShadow = properties.castShadow;
+        if (properties.shadowMapResolution) this.#shadowMapResolution = properties.shadowMapResolution;
+        if (properties.shadowMapBias) this.#shadowMapBias = properties.shadowMapBias;
     }
 
     // #endregion Constructors (1)
 
-    // #region Public Accessors (8)
+    // #region Public Getters And Setters (8)
 
     public get castShadow(): boolean {
         return this.#castShadow;
@@ -58,7 +55,7 @@ export class DirectionalLight extends AbstractLight implements IDirectionalLight
     public set castShadow(value: boolean) {
         this.#castShadow = value;
         this.updateVersion();
-        if(this.parentNode) this.parentNode.updateVersion();
+        if (this.parentNode) this.parentNode.updateVersion();
     }
 
     public get direction(): vec3 {
@@ -68,7 +65,7 @@ export class DirectionalLight extends AbstractLight implements IDirectionalLight
     public set direction(value: vec3) {
         this.#direction = value;
         this.updateVersion();
-        if(this.parentNode) this.parentNode.updateVersion();
+        if (this.parentNode) this.parentNode.updateVersion();
     }
 
     public get shadowMapBias(): number {
@@ -78,7 +75,7 @@ export class DirectionalLight extends AbstractLight implements IDirectionalLight
     public set shadowMapBias(value: number) {
         this.#shadowMapBias = value;
         this.updateVersion();
-        if(this.parentNode) this.parentNode.updateVersion();
+        if (this.parentNode) this.parentNode.updateVersion();
     }
 
     public get shadowMapResolution(): number {
@@ -88,14 +85,10 @@ export class DirectionalLight extends AbstractLight implements IDirectionalLight
     public set shadowMapResolution(value: number) {
         this.#shadowMapResolution = value;
         this.updateVersion();
-        if(this.parentNode) this.parentNode.updateVersion();
-    }
-
-    public get threeJsObject(): { [key: string]: THREE.DirectionalLight } {
-        return this.#threeJsObject;
+        if (this.parentNode) this.parentNode.updateVersion();
     }
 
-    // #endregion Public Accessors (8)
+    // #endregion Public Getters And Setters (8)
 
     // #region Public Methods (1)
 

package/src/implementation/types/HemisphereLight.ts

@@ -1,16 +1,12 @@
-import { ITreeNodeData } from '@shapediver/viewer.shared.node-tree'
-import { vec3 } from 'gl-matrix'
+import { AbstractLight } from '../AbstractLight';
 import { Color } from '@shapediver/viewer.shared.types';
-
-import { LIGHT_TYPE } from '../../interface/ILight'
 import { IHemisphereLight } from '../../interface/types/IHemisphereLight';
-import { AbstractLight } from '../AbstractLight'
+import { LIGHT_TYPE } from '../../interface/ILight';
 
 export class HemisphereLight extends AbstractLight implements IHemisphereLight {
     // #region Properties (1)
 
     #groundColor: Color = '#000000';
-    #threeJsObject: { [key: string]: THREE.HemisphereLight } = {};
 
     // #endregion Properties (1)
 
@@ -40,7 +36,7 @@ export class HemisphereLight extends AbstractLight implements IHemisphereLight {
 
     // #endregion Constructors (1)
 
-    // #region Public Accessors (2)
+    // #region Public Getters And Setters (2)
 
     public get groundColor(): Color {
         return this.#groundColor;
@@ -49,14 +45,10 @@ export class HemisphereLight extends AbstractLight implements IHemisphereLight {
     public set groundColor(value: Color) {
         this.#groundColor = value;
         this.updateVersion();
-        if(this.parentNode) this.parentNode.updateVersion();
-    }
-
-    public get threeJsObject(): { [key: string]: THREE.HemisphereLight } {
-        return this.#threeJsObject;
+        if (this.parentNode) this.parentNode.updateVersion();
     }
 
-    // #endregion Public Accessors (2)
+    // #endregion Public Getters And Setters (2)
 
     // #region Public Methods (1)
 

package/src/implementation/types/PointLight.ts

@@ -1,10 +1,8 @@
-import { ITreeNodeData } from '@shapediver/viewer.shared.node-tree'
-import { vec3 } from 'gl-matrix'
+import { AbstractLight } from '../AbstractLight';
 import { Color } from '@shapediver/viewer.shared.types';
-
-import { LIGHT_TYPE } from '../../interface/ILight'
 import { IPointLight } from '../../interface/types/IPointLight';
-import { AbstractLight } from '../AbstractLight'
+import { LIGHT_TYPE } from '../../interface/ILight';
+import { vec3 } from 'gl-matrix';
 
 export class PointLight extends AbstractLight implements IPointLight {
   // #region Properties (3)
@@ -12,7 +10,6 @@ export class PointLight extends AbstractLight implements IPointLight {
   #decay: number = 0;
   #distance: number = 0;
   #position: vec3 = vec3.fromValues(0, 0, 0);
-  #threeJsObject: { [key: string]: THREE.PointLight } = {};
 
   // #endregion Properties (3)
 
@@ -45,7 +42,7 @@ export class PointLight extends AbstractLight implements IPointLight {
 
   // #endregion Constructors (1)
 
-  // #region Public Accessors (6)
+  // #region Public Getters And Setters (6)
 
   public get decay(): number {
     return this.#decay;
@@ -54,7 +51,7 @@ export class PointLight extends AbstractLight implements IPointLight {
   public set decay(value: number) {
     this.#decay = value;
     this.updateVersion();
-    if(this.parentNode) this.parentNode.updateVersion();
+    if (this.parentNode) this.parentNode.updateVersion();
   }
 
   public get distance(): number {
@@ -64,7 +61,7 @@ export class PointLight extends AbstractLight implements IPointLight {
   public set distance(value: number) {
     this.#distance = value;
     this.updateVersion();
-    if(this.parentNode) this.parentNode.updateVersion();
+    if (this.parentNode) this.parentNode.updateVersion();
   }
 
   public get position(): vec3 {
@@ -74,14 +71,10 @@ export class PointLight extends AbstractLight implements IPointLight {
   public set position(value: vec3) {
     this.#position = value;
     this.updateVersion();
-    if(this.parentNode) this.parentNode.updateVersion();
-  }
-
-  public get threeJsObject(): { [key: string]: THREE.PointLight } {
-      return this.#threeJsObject;
+    if (this.parentNode) this.parentNode.updateVersion();
   }
 
-  // #endregion Public Accessors (6)
+  // #endregion Public Getters And Setters (6)
 
   // #region Public Methods (1)