@needle-tools/engine 3.2.5-alpha → 3.2.6-alpha

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@needle-tools/engine",
-    "version": "3.2.5-alpha",
+    "version": "3.2.6-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,12 +27,15 @@ 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";
 export * from "./engine_types";
 export * from "./engine_utils_screenshot";

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_rendererdata.ts → engine_scenelighting.ts}

@@ -1,17 +1,18 @@
-import { Vector4, EquirectangularReflectionMapping, sRGBEncoding, WebGLCubeRenderTarget, Texture, LightProbe, Color } from "three";
+import { Vector4, EquirectangularReflectionMapping, sRGBEncoding, WebGLCubeRenderTarget, Texture, LightProbe, Color, SphericalHarmonics3 } from "three";
 import { LightProbeGenerator } from "three/examples/jsm/lights/LightProbeGenerator.js"
 import { Context } from "./engine_setup";
 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");
 
 
 export declare type SphericalHarmonicsData = {
     array: number[],
-    texture: THREE.WebGLCubeRenderTarget | THREE.Texture,
+    texture: WebGLCubeRenderTarget | Texture,
     lightProbe?: LightProbe
 }
 
@@ -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);
     }
 
-    registerReflection(sourceId: SourceIdentifier, reflectionTexture: Texture) {
+    /** @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);
+    }
+
+    /** @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)!);
@@ -178,13 +248,13 @@ export class LightData {
     get Array(): number[] | undefined { return this._sphericalHarmonicsArray; }
 
     private _context: Context;
-    private _source: THREE.Texture;
-    private _sphericalHarmonics: THREE.SphericalHarmonics3 | null = null;
+    private _source: Texture;
+    private _sphericalHarmonics: SphericalHarmonics3 | null = null;
     private _sphericalHarmonicsArray?: number[];
     private _ambientScale: number = 1;
     private _lightProbe?: LightProbe;
 
-    constructor(context: Context, tex: THREE.Texture, ambientScale: number = 1) {
+    constructor(context: Context, tex: Texture, ambientScale: number = 1) {
         this._context = context;
         this._source = tex;
         this._ambientScale = ambientScale;
@@ -199,13 +269,14 @@ export class LightData {
 
         try {
             const reflection = this._source;
-            let rt: THREE.WebGLCubeRenderTarget | null = null;
+            let rt: WebGLCubeRenderTarget | null = null;
             if (reflection) {
                 if (debug) console.log("GENERATING LIGHT PROBE", reflection, this.Source);
                 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 = [];
@@ -216,13 +287,15 @@ export class LightData {
                 // console.log(intensityFactor, lightFactor);
                 this._sphericalHarmonics = sampledProbe.sh;
                 this._sphericalHarmonicsArray = this._sphericalHarmonics.toArray();
-                const factor = ((intensityFactor) / (Math.PI * .5));
-                for (let i = 0; i < this._sphericalHarmonicsArray.length; i++) {
-                    this._sphericalHarmonicsArray[i] *= factor;
+                if (this._sphericalHarmonicsArray) {
+                    const factor = ((intensityFactor) / (Math.PI * .5));
+                    for (let i = 0; i < this._sphericalHarmonicsArray.length; i++) {
+                        this._sphericalHarmonicsArray[i] *= factor;
+                    }
+                    sampledProbe.sh.scale(lightFactor);
+                    if (this._source)
+                        return { array: this._sphericalHarmonicsArray, texture: this._source, lightProbe: sampledProbe };
                 }
-                sampledProbe.sh.scale(lightFactor);
-                if (this._source)
-                    return { array: this._sphericalHarmonicsArray, texture: this._source, lightProbe: sampledProbe };
             }
         }
         catch (err) {

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,12 @@ 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";
 
 export const EXTENSION_NAME = "NEEDLE_lighting_settings";
 const debug = getParam("debugenvlight");
@@ -42,7 +43,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 +51,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 +64,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 +71,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 +90,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 +100,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 +118,17 @@ 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);
+    }
+
+    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);
+                if (debug) console.log("Created ambient light", this.sourceId, this._ambientLightObj)
             }
             if (this._ambientLightObj) {
                 this.gameObject.add(this._ambientLightObj)
@@ -129,23 +139,24 @@ 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)
+                this._hemisphereLightObj = new HemisphereLight(sky, ground, this.ambientIntensity);
+                this.gameObject.add(this._hemisphereLightObj)
             }
         }
         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 +170,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"

package/src/engine-components/Component.ts

@@ -470,7 +470,13 @@ export class Component implements IComponent, EventTarget {
 
     /** @internal */
     __internalEnable(): boolean {
-        if (this.__didEnable) return false;
+        // Don't change enable before awake
+        // But a user can change enable during awake
+        if (!this.__didAwake) return false;
+        if (this.__didEnable) {
+            this.__isEnabled = true;
+            return false;
+        }
         // console.trace("INTERNAL ENABLE");
         this.__didEnable = true;
         this.onEnable();
@@ -480,7 +486,13 @@ export class Component implements IComponent, EventTarget {
 
     /** @internal */
     __internalDisable() {
-        if (!this.__didEnable) return;
+        // Don't change enable before awake
+        // But a user can change enable during awake
+        if (!this.__didAwake) return;
+        if (!this.__didEnable) {
+            this.__isEnabled = false;
+            return;
+        }
         this.__didEnable = false;
         this.onDisable();
         this.__isEnabled = false;
@@ -496,7 +508,7 @@ export class Component implements IComponent, EventTarget {
 
 
     get enabled(): boolean {
-        return this.__isEnabled ?? true; // if it has no enabled field it is always enabled
+        return typeof this.__isEnabled === "boolean" ? this.__isEnabled : true; // if it has no enabled field it is always enabled
     }
     set enabled(val: boolean) {
         // when called from animationclip we receive numbers

package/src/engine-components/Renderer.ts

@@ -617,7 +617,7 @@ export class Renderer extends Behaviour implements IRenderer {
 
         if (material.envMapIntensity !== undefined) {
             const factor = this.hasLightmap ? Math.PI : 1;
-            material.envMapIntensity = Math.max(0, this.context.rendererData.environmentIntensity / factor);
+            material.envMapIntensity = Math.max(0, this.context.sceneLighting.environmentIntensity / factor);
         }
         // if (this._reflectionProbe?.texture) {
         //     material.envMap = this._reflectionProbe.texture;