@needle-tools/engine 3.2.5-alpha.1 → 3.2.7-alpha

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@needle-tools/engine",
-    "version": "3.2.5-alpha.1",
+    "version": "3.2.7-alpha",
     "description": "Needle Engine is a web-based runtime for 3D apps. It runs on your machine for development with great integrations into editors like Unity or Blender - and can be deployed onto any device! It is flexible, extensible and networking and XR are built-in",
     "main": "dist/needle-engine.umd.cjs",
     "type": "module",

package/src/engine/api.ts

@@ -1,5 +1,5 @@
 
-export * from "./extensions/extensions"
+export * from "./extensions"
 export * from "./engine_addressables";
 export * from "./engine_application"
 export * from "./engine_assetdatabase"
@@ -27,11 +27,13 @@ export * from "./engine_patcher"
 export * from "./engine_playerview"
 export * from "./engine_physics"
 export * from "./engine_physics.types"
+export * from "./engine_scenelighting"
 export * from "./engine_input";
 export * from "./engine_math";
 export * from "./js-extensions";
 export * from "./engine_scenetools";
 export * from "./engine_serialization";
+export { type ISerializable } from "./engine_serialization_core";
 export * from "./engine_texture";
 export * from "./engine_three_utils";
 export * from "./engine_time";

package/src/engine/codegen/register_types.js

@@ -1,5 +1,5 @@
 import { TypeStore } from "./../engine_typestore"
-
+
 // Import types
 import { __Ignore } from "../../engine-components/codegen/components";
 import { AlignmentConstraint } from "../../engine-components/AlignmentConstraint";
@@ -187,7 +187,7 @@ import { XRGrabModel } from "../../engine-components/webxr/WebXRGrabRendering";
 import { XRGrabRendering } from "../../engine-components/webxr/WebXRGrabRendering";
 import { XRRig } from "../../engine-components/webxr/WebXRRig";
 import { XRState } from "../../engine-components/XRFlag";
-
+
 // Register types
 TypeStore.add("__Ignore", __Ignore);
 TypeStore.add("AlignmentConstraint", AlignmentConstraint);

package/src/engine/engine_context.ts

@@ -18,7 +18,7 @@ import { AssetDatabase } from './engine_assetdatabase';
 import { logHierarchy } from './engine_three_utils';
 
 import * as Stats from 'three/examples/jsm/libs/stats.module';
-import { RendererData } from './engine_rendererdata';
+import { RendererData as SceneLighting } from './engine_scenelighting';
 import { Addressables } from './engine_addressables';
 import { Application } from './engine_application';
 import { LightDataRegistry, ILightDataRegistry } from './engine_lightdata';
@@ -225,7 +225,9 @@ export class Context implements IContext {
 	 */
 	assets: AssetDatabase;
 	mainLight: ILight | null = null;
-	rendererData: RendererData;
+	/** @deprecated Use sceneLighting */
+	get rendererData() { return this.sceneLighting }
+	sceneLighting: SceneLighting;
 	addressables: Addressables;
 	lightmaps: ILightDataRegistry;
 	players: PlayerViewManager;
@@ -278,7 +280,7 @@ export class Context implements IContext {
 		this.physics = new Physics(this);
 		this.connection = new NetworkConnection(this);
 		this.assets = new AssetDatabase();
-		this.rendererData = new RendererData(this);
+		this.sceneLighting = new SceneLighting(this);
 		this.addressables = new Addressables(this);
 		this.lightmaps = new LightDataRegistry(this);
 		this.players = new PlayerViewManager(this);

package/src/engine/engine_element_loading.ts

@@ -176,7 +176,6 @@ export class EngineLoadingView implements ILoadingViewHandler {
         this._loadingElement = existing || document.createElement("div");
 
         const loadingStyle: LoadingStyleOption = this._element.getAttribute("loading-style") as LoadingStyleOption;
-        console.log(loadingStyle);
 
         const hasLicense = hasProLicense();
         if (!existing) {

package/src/engine/engine_mainloop_utils.ts

@@ -267,8 +267,10 @@ function updateIsActiveInHierarchyRecursiveRuntime(go: Object3D, activeInHierarc
                 if (activeInHierarchy) {
                     if (comp.enabled) {
                         utils.safeInvoke(comp.__internalAwake.bind(comp));
-                        comp["__didEnable"] = true;
-                        comp.onEnable();
+                        if (comp.enabled) {
+                            comp["__didEnable"] = true;
+                            comp.onEnable();
+                        }
                     }
                 }
                 else {

package/src/engine/engine_physics.ts

@@ -1082,7 +1082,7 @@ class PhysicsCollisionHandler {
         // if one is a trigger we dont get collisions but want to raise the trigger events
         if (self.isTrigger || other.isTrigger) {
             foreachComponent(self.gameObject, (c: IComponent) => {
-                if (c.onTriggerEnter) {
+                if (c.onTriggerEnter && !c.destroyed) {
                     c.onTriggerEnter(other);
                 }
                 this.activeTriggers.push({ collider: self, component: c, otherCollider: other });
@@ -1093,6 +1093,7 @@ class PhysicsCollisionHandler {
             // TODO: we dont respect the flip value here!
             this.world.contactPair(selfBody, otherBody, (manifold, _flipped) => {
                 foreachComponent(object, (c: IComponent) => {
+                    if(c.destroyed) return;
                     const hasDeclaredEventMethod = c.onCollisionEnter || c.onCollisionStay || c.onCollisionExit;
                     if (hasDeclaredEventMethod || debugCollisions) {
                         if (!collision) {
@@ -1137,6 +1138,7 @@ class PhysicsCollisionHandler {
     private onHandleCollisionStay() {
         for (const active of this.activeCollisionsStay) {
             const c = active.component;
+            if(c.destroyed) continue;
             if (c.activeAndEnabled && c.onCollisionStay) {
                 const arg = active.collision;
                 c.onCollisionStay(arg);
@@ -1144,6 +1146,7 @@ class PhysicsCollisionHandler {
         }
         for (const active of this.activeTriggers) {
             const c = active.component;
+            if(c.destroyed) continue;
             if (c.activeAndEnabled && c.onTriggerStay) {
                 const arg = active.otherCollider;
                 c.onTriggerStay(arg);
@@ -1152,9 +1155,15 @@ class PhysicsCollisionHandler {
     }
 
     private onCollisionEnded(self: ICollider, other: ICollider) {
+        if(self.destroyed || other.destroyed) return;
         for (let i = 0; i < this.activeCollisions.length; i++) {
             const active = this.activeCollisions[i];
             const collider = active.collider;
+            if(collider.destroyed) {
+                this.activeCollisions.splice(i, 1);
+                i--;
+                continue;
+            }
             if (collider === self && active.collision.collider === other) {
                 const c = active.component;
                 this.activeCollisions.splice(i, 1);
@@ -1168,6 +1177,11 @@ class PhysicsCollisionHandler {
         for (let i = 0; i < this.activeCollisionsStay.length; i++) {
             const active = this.activeCollisionsStay[i];
             const collider = active.collider;
+            if(collider.destroyed) {
+                this.activeCollisionsStay.splice(i, 1);
+                i--;
+                continue;
+            }
             if (collider === self && active.collision.collider === other) {
                 const c = active.component;
                 this.activeCollisionsStay.splice(i, 1);
@@ -1181,6 +1195,11 @@ class PhysicsCollisionHandler {
         for (let i = 0; i < this.activeTriggers.length; i++) {
             const active = this.activeTriggers[i];
             const collider = active.collider;
+            if(collider.destroyed) {
+                this.activeTriggers.splice(i, 1);
+                i--;
+                continue;
+            }
             if (collider === self && active.otherCollider === other) {
                 const c = active.component;
                 this.activeTriggers.splice(i, 1);

package/src/engine/{engine_rendererdata.ts → engine_scenelighting.ts}

@@ -5,6 +5,7 @@ import { SceneLightSettings } from "./extensions/NEEDLE_lighting_settings";
 import { createFlatTexture, createTrilightTexture } from "./engine_shaders";
 import { getParam } from "./engine_utils";
 import { SourceIdentifier } from "./engine_types";
+import { AssetReference } from "./engine_addressables";
 
 const debug = getParam("debugenvlight");
 
@@ -36,8 +37,8 @@ export class RendererData {
         this.context.pre_update_callbacks.push(this.preUpdate.bind(this))
     }
 
-    private _currentReflectionId?: SourceIdentifier;
-    private sceneLightSettings?: Map<SourceIdentifier, SceneLightSettings>;
+    private _currentLightSettingsId?: SourceIdentifier;
+    private _sceneLightSettings?: Map<SourceIdentifier, SceneLightSettings>;
 
     private preUpdate() {
         const time = this.context.time;
@@ -52,40 +53,103 @@ export class RendererData {
         return this._timevec4;
     }
 
+    /** the current environment intensity */
     get environmentIntensity(): number {
-        if (!this.sceneLightSettings) return 1;
-        if (!this._currentReflectionId) return 1;
-        const settings = this.sceneLightSettings.get(this._currentReflectionId);
-        if(settings)
+        if (!this._sceneLightSettings) return 1;
+        if (!this._currentLightSettingsId) return 1;
+        const settings = this._sceneLightSettings.get(this._currentLightSettingsId);
+        if (settings)
             return settings.ambientIntensity;// * Math.PI * .5;
         return 1;
     }
 
-    registerSceneLightSettings(sceneLightSettings: SceneLightSettings) {
+    /** Get all currently registered scene light settings */
+    get sceneLightSettings() { return this._sceneLightSettings?.values() }
+
+    /** set the scene lighting from a specific scene. Will disable any previously enabled lighting settings */
+    enable(sourceId: SourceIdentifier | AssetReference) {
+        if(sourceId instanceof AssetReference)
+            sourceId = sourceId.uri;
+        const settings = this._sceneLightSettings?.get(sourceId);
+        if (!settings) {
+            return false;
+        }
+        if (debug) console.log("Enable scene light settings", sourceId, settings);
+        if (sourceId !== this._currentLightSettingsId && this._currentLightSettingsId) {
+            this.disable(this._currentLightSettingsId);
+        }
+        this._currentLightSettingsId = sourceId;
+        settings.enabled = true;
+        return true;
+    }
+
+    /** disable the lighting of a specific scene, will only have any effect if it is currently active */
+    disable(sourceId: SourceIdentifier | AssetReference) {
+        if(sourceId instanceof AssetReference)
+            sourceId = sourceId.uri;
+        if (sourceId === null || sourceId === undefined) return false;
+        const settings = this._sceneLightSettings?.get(sourceId);
+        if (!settings) {
+            return false;
+        }
+        if (debug) console.log("Disable scene light settings", sourceId, settings);
+        settings.enabled = false;
+        return true;
+    }
+
+    /** Disables the currently active scene lighting (if any), returns the id of the previously active lighting */
+    disableCurrent() : SourceIdentifier | null {
+        if (this._currentLightSettingsId) {
+            const prev = this._currentLightSettingsId;
+            this.disable(this._currentLightSettingsId);
+            return prev
+        }
+        return null;
+    }
+
+
+    /** @internal */
+    internalRegisterSceneLightSettings(sceneLightSettings: SceneLightSettings) {
         const sourceId = sceneLightSettings.sourceId;
-        if(!sourceId){
+        if (!sourceId) {
             console.error("Missing source id for scene light settings, can not register:", sceneLightSettings);
             return;
         }
-        if (debug) console.log("Register lighting settings", sceneLightSettings?.sourceId, sceneLightSettings);
-        if (!this.sceneLightSettings) this.sceneLightSettings = new Map();
-        this.sceneLightSettings.set(sourceId, sceneLightSettings);
+        if (debug) console.log("Register " + sceneLightSettings?.sourceId + " lighting", sceneLightSettings);
+        if (!this._sceneLightSettings) this._sceneLightSettings = new Map();
+        this._sceneLightSettings.set(sourceId, sceneLightSettings);
+    }
+
+    /** @internal */
+    internalUnregisterSceneLightSettings(sceneLightSettings: SceneLightSettings) {
+        const sourceId = sceneLightSettings.sourceId;
+        if (!sourceId) {
+            console.error("Missing source id for scene light settings, can not unregister:", sceneLightSettings);
+            return;
+        }
+        if (debug) console.log("Unregister " + sceneLightSettings?.sourceId + " lighting", sceneLightSettings);
+        if (!this._sceneLightSettings) return;
+        this._sceneLightSettings.delete(sourceId);
     }
 
-    registerReflection(sourceId: SourceIdentifier, reflectionTexture: Texture) {
+    /** @internal */
+    internalRegisterReflection(sourceId: SourceIdentifier, reflectionTexture: Texture) {
         if (debug) console.log("Register reflection", sourceId, reflectionTexture);
         const h = new LightData(this.context, reflectionTexture, 1);
         this._lighting[sourceId] = h;
     }
 
-    getReflection(sourceId: SourceIdentifier): LightData | null | undefined {
+    /** @internal */
+    internalGetReflection(sourceId: SourceIdentifier): LightData | null | undefined {
         return this._lighting[sourceId];
     }
 
-    enableReflection(sourceId: SourceIdentifier) {
-        const previousId = this._currentReflectionId;
-        this._currentReflectionId = sourceId;
-        const settings = this.sceneLightSettings?.get(sourceId);
+    private __currentReflectionId: SourceIdentifier | null = null;
+
+    /** @internal */
+    internalEnableReflection(sourceId: SourceIdentifier) {
+        this.__currentReflectionId = sourceId;
+        const settings = this._sceneLightSettings?.get(sourceId);
 
         if (debug) {
             console.log("Enable reflection", sourceId, settings ? AmbientMode[settings.ambientMode] : "Unknown ambient mode");
@@ -95,9 +159,9 @@ export class RendererData {
             case AmbientMode.Skybox:
             case AmbientMode.Custom:
                 // only set environment reflection when ambient mode is skybox or custom
-                const existing = this.getReflection(sourceId);
+                const existing = this.internalGetReflection(sourceId);
                 if (existing && existing.Source) {
-                    if (debug) console.log("Setting environment reflection", existing.Source);
+                    if (debug) console.log("Setting environment reflection", existing);
                     const scene = this.context.scene;
                     const tex = existing.Source;
                     tex.encoding = sRGBEncoding;
@@ -136,13 +200,19 @@ export class RendererData {
         }
     }
 
-    disableReflection(sourceId?: SourceIdentifier) {
-        if (sourceId && sourceId !== this._currentReflectionId) return;
+    /** @internal */
+    internalDisableReflection(sourceId?: SourceIdentifier) {
+        if (sourceId && sourceId !== this.__currentReflectionId) {
+            if(debug) console.log("Not disabling reflection for", sourceId, "because it is not the current light settings id", this.__currentReflectionId)
+            return;
+        }
+        if (debug) console.log("Disable reflection", sourceId)
         const scene = this.context.scene;
         scene.environment = null;
     }
 
-    async getSceneLightingData(sourceId: SourceIdentifier): Promise<SphericalHarmonicsData> {
+    /** @internal */
+    async internalGetSceneLightingData(sourceId: SourceIdentifier): Promise<SphericalHarmonicsData> {
         if (debug)
             console.log("GET SCENE LIGHT DATA", sourceId);
 
@@ -157,7 +227,7 @@ export class RendererData {
         if (this._waitPromise) return this._waitPromise;
         this._waitPromise = new Promise((res, _rej) => {
             let interval = setInterval(async () => {
-                const ex = this.getReflection(sourceId);
+                const ex = this.internalGetReflection(sourceId);
                 if (ex) {
                     clearInterval(interval);
                     res(ex.getSphericalHarmonicsArray(this.environmentIntensity ?? 1)!);
@@ -205,7 +275,8 @@ export class LightData {
                 const size = Math.min(reflection.image.width, 512);
                 const target = new WebGLCubeRenderTarget(size);
                 rt = target.fromEquirectangularTexture(this._context.renderer, reflection);
-                this._source = rt.texture;
+                // Not sure why we did assign the resulting texture here again but this causes rendering to break when toggling env lighting (e.g. on website) because this texture will then be set as the scene.environment
+                // this._source = rt.texture;
             }
 
             this._sphericalHarmonicsArray = [];

package/src/engine/engine_serialization_core.ts

@@ -3,7 +3,7 @@ import { getParam } from "./engine_utils";
 import { AnimationClip, Material, Mesh, Object3D, Texture } from "three";
 import { Context } from "./engine_setup";
 import { isPersistentAsset } from "./extensions/NEEDLE_persistent_assets";
-import { SourceIdentifier } from "./engine_types";
+import { ConstructorConcrete, SourceIdentifier } from "./engine_types";
 import { debugExtension } from "../engine/engine_default_parameters";
 import { LogType, addLog } from "./debug/debug_overlay";
 import { isLocalNetwork } from "./engine_networking_utils";
@@ -12,7 +12,6 @@ import { $BuiltInTypeFlag } from "./engine_typestore";
 const debug = getParam("debugserializer");
 
 
-export type Constructor<T> = { new(...args: any[]): T };
 export declare type NodeToObjectMap = { [nodeId: string]: Object3D };
 export declare type ObjectToNodeMap = { [uuid: string]: number };
 
@@ -125,7 +124,7 @@ export abstract class TypeSerializer implements ITypeSerializer {
     //     }
     // }
 
-    constructor(type: Constructor<any> | Constructor<any>[]) {
+    constructor(type: ConstructorConcrete<any> | ConstructorConcrete<any>[]) {
         if (Array.isArray(type)) {
             for (const key of type)
                 helper.register(key.name, this);
@@ -141,7 +140,7 @@ export abstract class TypeSerializer implements ITypeSerializer {
 
 
 export interface ITypeInformation {
-    type?: Constructor<any>;
+    type?: ConstructorConcrete<any>;
 }
 
 /** holds information if a field was undefined before serialization. This gives us info if we might want to warn the user about missing attributes */
@@ -182,7 +181,7 @@ export class SerializationContext {
     objectToNode?: ObjectToNodeMap;
     context?: Context;
     path?: string;
-    type?: Constructor<any>;
+    type?: ConstructorConcrete<any>;
     /** holds information if a field was undefined before serialization. This gives us info if we might want to warn the user about missing attributes */
     implementationInformation?: ImplementationInformation;
 
@@ -193,7 +192,7 @@ export class SerializationContext {
 
 
 export interface ISerializable {
-    $serializedTypes?: { [key: string]: Constructor<any> | ITypeInformation | null };
+    $serializedTypes?: { [key: string]: ConstructorConcrete<any> | ITypeInformation | null };
     // onDeserialize?(context: SerializationContext): void;
     // example:
     /* $serializedTypes : {
@@ -337,7 +336,7 @@ export function deserializeObject(obj: ISerializable, serializedData: object, co
                     }
                     // it can also just contain a constructor
                     else {
-                        const constructor = typeInfoOrConstructor as Constructor<any>;
+                        const constructor = typeInfoOrConstructor as ConstructorConcrete<any>;
                         return deserializeObjectWithType(data, constructor, context, undefined, obj[key]);
                     }
                 }
@@ -460,7 +459,7 @@ declare type TypeDeserializeReference = {
     serializer?: ITypeSerializer
 }
 
-function deserializeObjectWithType(data: any, typeOrConstructor: Constructor<any>, context: SerializationContext, typeContext?: TypeDeserializeReference, currentValue?: any): any {
+function deserializeObjectWithType(data: any, typeOrConstructor: ConstructorConcrete<any>, context: SerializationContext, typeContext?: TypeDeserializeReference, currentValue?: any): any {
 
     // e.g. @serializable((data) => { })
     let typeIsFunction = typeof typeOrConstructor === "function" && (typeOrConstructor.prototype === undefined);

package/src/engine/extensions/NEEDLE_lighting_settings.ts

@@ -2,11 +2,13 @@ import { AmbientLight, Color, HemisphereLight, Object3D } from "three";
 import { GLTF, GLTFLoaderPlugin, GLTFParser } from "three/examples/jsm/loaders/GLTFLoader";
 import { SourceIdentifier } from "../engine_types";
 import { Behaviour, GameObject } from "../../engine-components/Component";
-import { AmbientMode, DefaultReflectionMode } from "../engine_rendererdata";
+import { AmbientMode, DefaultReflectionMode } from "../engine_scenelighting";
 import { LightmapType } from "./NEEDLE_lightmaps";
 import { getParam } from "../engine_utils";
 import { Context } from "../engine_setup";
 import { LightProbe } from "three";
+import { ContextEvent, ContextRegistry } from "../engine_context_registry";
+import { Mathf } from "../engine_math";
 
 export const EXTENSION_NAME = "NEEDLE_lighting_settings";
 const debug = getParam("debugenvlight");
@@ -42,7 +44,7 @@ export class NEEDLE_lighting_settings implements GLTFLoaderPlugin {
             const ext: LightingSettings = extensions[EXTENSION_NAME];
             if (ext) {
                 if (debug)
-                    console.log("Apply \"" + this.name + "\", src: \"" + this.sourceId + "\"", ext);
+                    console.log("Loaded \"" + this.name + "\", src: \"" + this.sourceId + "\"", ext);
                 let settings: SceneLightSettings | undefined = undefined;
                 // If the result scene has only one child we add the LightingSettingsComponent to that child
                 if (_result.scene.children.length === 1) {
@@ -50,10 +52,9 @@ export class NEEDLE_lighting_settings implements GLTFLoaderPlugin {
                     settings = GameObject.addNewComponent(_result.scene.children[0], SceneLightSettings, false);
                 }
                 // if the scene already has multiple children we add it as a new object
-                else 
-                {
+                else {
                     const lightSettings = new Object3D();
-                    lightSettings.name = "Needle LightSettings";
+                    lightSettings.name = "LightSettings " + this.sourceId;
                     _result.scene.add(lightSettings);
                     settings = GameObject.addNewComponent(lightSettings, SceneLightSettings, false);
                 }
@@ -64,7 +65,6 @@ export class NEEDLE_lighting_settings implements GLTFLoaderPlugin {
                     settings.ambientTrilight = ext.ambientTrilight.map(c => new Color().fromArray(c));
                 settings.ambientMode = ext.ambientMode;
                 settings.environmentReflectionSource = ext.environmentReflectionSource;
-                if (this.context) this.context.rendererData.registerSceneLightSettings(settings);
             }
         }
         return null;
@@ -72,6 +72,12 @@ export class NEEDLE_lighting_settings implements GLTFLoaderPlugin {
 
 }
 
+ContextRegistry.registerCallback(ContextEvent.ContextCreated, e => {
+    const ctx = e.context as Context;
+    const lightingSettings = GameObject.findObjectOfType(SceneLightSettings, ctx as Context);
+    if (lightingSettings?.sourceId) ctx.sceneLighting.enable(lightingSettings.sourceId);
+})
+
 // exists once per gltf scene root (if it contains reflection)
 // when enabled it does currently automatically set the reflection
 // this might not be desireable
@@ -85,6 +91,7 @@ export class SceneLightSettings extends Behaviour {
 
     private _hasReflection: boolean = false;
     private _ambientLightObj?: AmbientLight;
+    private _hemisphereLightObj?: HemisphereLight;
     // used when skybox is used to support ambient intensity for "non custom shaders"
     private _lightProbeObj?: LightProbe;
 
@@ -94,11 +101,15 @@ export class SceneLightSettings extends Behaviour {
             const tex = this.context.lightmaps.tryGet(this.sourceId, type, 0);
             this._hasReflection = tex !== null && tex !== undefined;
             if (tex)
-                this.context.rendererData.registerReflection(this.sourceId, tex);
+                this.context.sceneLighting.internalRegisterReflection(this.sourceId, tex);
         }
 
+        this.enabled = false;
+        this.context.sceneLighting.internalRegisterSceneLightSettings(this);
+
         if (debug) {
             window.addEventListener("keydown", evt => {
+                if(this.destroyed) return;
                 switch (evt.key) {
                     case "l":
                         this.enabled = !this.enabled;
@@ -108,17 +119,26 @@ export class SceneLightSettings extends Behaviour {
         }
     }
 
-    onEnable() {
-        const isActive = this.context.mainCameraComponent?.sourceId === this.sourceId;
-        if (debug) console.log("Enable scene lighting", this.sourceId, isActive, this, this.context.mainCameraComponent?.sourceId);
-        if (!isActive) {
-            if(debug) console.warn("This environment light is not active??!", this.context.mainCameraComponent?.sourceId)
-            this.enabled = false;
-            return;
-        }
+    onDestroy(): void {
+        this.context.sceneLighting.internalUnregisterSceneLightSettings(this);
+    }
+
+    private calculateIntensityFactor(col:Color){
+        const intensity = Math.max(col.r, col.g, col.b);// * 0.2126 + col.g * 0.7152 + col.b * 0.0722;
+        const factor = 2.2 * Mathf.lerp(0, 1.33, intensity); // scale based on intensity
+        return factor;
+    }
+
+    onEnable(): void {
+        if (debug) console.warn("💡🟡 >>> Enable lighting", this.sourceId, this);
+
         if (this.ambientMode == AmbientMode.Flat) {
             if (this.ambientLight && !this._ambientLightObj) {
-                this._ambientLightObj = new AmbientLight(this.ambientLight, this.ambientIntensity);
+                // TODO: currently ambient intensity is always exported as 1? The exported values are not correct in threejs
+                // the following calculation is a workaround to get the correct intensity
+                const factor = this.calculateIntensityFactor(this.ambientLight);
+                this._ambientLightObj = new AmbientLight(this.ambientLight, this.ambientIntensity * factor);
+                if (debug) console.log("Created ambient light", this.sourceId, this._ambientLightObj, this.ambientIntensity, factor)
             }
             if (this._ambientLightObj) {
                 this.gameObject.add(this._ambientLightObj)
@@ -129,23 +149,26 @@ export class SceneLightSettings extends Behaviour {
             if (this.ambientTrilight) {
                 const ground = this.ambientTrilight[0];
                 const sky = this.ambientTrilight[this.ambientTrilight.length - 1];
-                const hemisphere = new HemisphereLight(sky, ground, this.ambientIntensity);
-                this.gameObject.add(hemisphere)
+                const factor = this.calculateIntensityFactor(sky);
+                this._hemisphereLightObj = new HemisphereLight(sky, ground, this.ambientIntensity * factor);
+                this.gameObject.add(this._hemisphereLightObj)
+                if (debug) console.log("Created hemisphere ambient light", this.sourceId, this._hemisphereLightObj, this.ambientIntensity, factor)
             }
         }
         else {
             if (this._ambientLightObj)
                 this._ambientLightObj.removeFromParent();
+            if (this._hemisphereLightObj)
+                this._hemisphereLightObj.removeFromParent();
 
             // create light probe object
             if (!this._lightProbeObj) {
                 if (this.sourceId) {
-                    this.context.rendererData.getSceneLightingData(this.sourceId).then(data => {
+                    this.context.sceneLighting.internalGetSceneLightingData(this.sourceId).then(data => {
                         if (!data) return;
                         this._lightProbeObj = data.lightProbe;
                         if (this.enabled && !this.destroyed && this._lightProbeObj) {
-                            if (debug)
-                                console.log("Add", this.sourceId, data);
+                            if (debug) console.log("Add", this.sourceId, data);
                             this.gameObject.add(this._lightProbeObj);
                         }
                     });
@@ -159,16 +182,20 @@ export class SceneLightSettings extends Behaviour {
         }
 
         if (this.sourceId)
-            this.context.rendererData.enableReflection(this.sourceId);
+            this.context.sceneLighting.internalEnableReflection(this.sourceId);
 
     }
 
     onDisable() {
         if (debug)
-            console.log("Disable envlight:", this.sourceId, this);
-        if (this._lightProbeObj) this._lightProbeObj.removeFromParent();
-        if(this._ambientLightObj) this._ambientLightObj.removeFromParent();
+            console.warn("💡⚫ <<< Disable lighting:", this.sourceId, this);
+        if (this._lightProbeObj)
+            this._lightProbeObj.removeFromParent();
+        if (this._ambientLightObj)
+            this._ambientLightObj.removeFromParent();
+        if (this._hemisphereLightObj)
+            this._hemisphereLightObj.removeFromParent();
         if (this.sourceId)
-            this.context.rendererData.disableReflection(this.sourceId);
+            this.context.sceneLighting.internalDisableReflection(this.sourceId);
     }
 }

package/src/engine/extensions/NEEDLE_techniques_webgl.ts

@@ -118,7 +118,7 @@ export class CustomShader extends RawShaderMaterial {
             console.error("Missing context");
             return;
         }
-        const data = await context.rendererData.getSceneLightingData(this.identifier);
+        const data = await context.sceneLighting.internalGetSceneLightingData(this.identifier);
         if (!data || !data.array) {
             console.warn("Missing lighting data for custom shader, getSceneLightingData did not return anything");
             return;
@@ -210,10 +210,10 @@ export class CustomShader extends RawShaderMaterial {
         // this._lastFrame = context.time.frame;
 
         if (this.uniforms["_TimeParameters"]) {
-            this.uniforms["_TimeParameters"].value = context.rendererData.timeVec4;
+            this.uniforms["_TimeParameters"].value = context.sceneLighting.timeVec4;
         }
         else if (this.uniforms["_Time"]) {
-            this.uniforms["_Time"].value = context.rendererData.timeVec4;
+            this.uniforms["_Time"].value = context.sceneLighting.timeVec4;
         }
 
         const mainLight: ILight | null = context.mainLight;

package/src/engine/extensions/index.ts

@@ -0,0 +1,5 @@
+export * from "./extensions"
+export * from "./NEEDLE_animator_controller_model"
+export * from "./NEEDLE_progressive"
+export { CustomShader } from "./NEEDLE_techniques_webgl"
+export { SceneLightSettings } from "./NEEDLE_lighting_settings"