@needle-tools/engine 2.24.0-pre

package/src/engine/engine_lightdata.ts

@@ -0,0 +1,111 @@
+import { LightmapType } from "./extensions/NEEDLE_lightmaps";
+import { Texture } from "three";
+import { SourceIdentifier } from "./engine_gltf";
+import { Context } from "./engine_setup";
+import * as THREE from "three";
+import { getParam } from "./engine_utils";
+
+const debugLightmap = getParam("debuglightmaps") ? true : false;
+
+export interface ILightDataRegistry {
+    registerTexture(sourceId: SourceIdentifier, type: LightmapType, texture: Texture, index?: number);
+    tryGet(sourceId: SourceIdentifier | undefined, type: LightmapType, index: number): Texture | null;
+    tryGetLightmap(sourceId: SourceIdentifier | null | undefined, index: number): Texture | null;
+    tryGetSkybox(sourceId?: SourceIdentifier | null): Texture | null;
+    tryGetReflection(sourceId?: SourceIdentifier | null): Texture | null;
+}
+
+// how do we know which lightmap should be used for which object
+// e.g. if we load in 3 gltf objects and all bring their own lightmaps
+// we need a good way for e.g. Renderer components to safely get THEIR lightmap 
+
+// similarly how do we deal with a gltf bringing its own skybox
+// e.g. it contains a camera and a skybox - the camera should be able to access this skybox if necessary
+// and reflection data should be accessible as well
+
+export class LightDataRegistry implements ILightDataRegistry {
+
+    private _context: Context;
+    private _lightmaps: Map<SourceIdentifier, Map<LightmapType, Texture[]>> = new Map();
+
+    constructor(context: Context) {
+        this._context = context;
+    }
+
+    registerTexture(sourceId: SourceIdentifier, type: LightmapType, tex: Texture, index: number) {
+        if (debugLightmap) console.log("Registering lightmap", sourceId, LightmapType[type], tex);
+        if (!this._lightmaps.has(sourceId))
+            this._lightmaps.set(sourceId, new Map());
+        const map = this._lightmaps.get(sourceId);
+        const arr = map?.get(type) ?? [];
+        if (arr.length < index) arr.length = index + 1;
+        arr[index] = tex;
+        map?.set(type, arr);
+    }
+
+    tryGetLightmap(sourceId: SourceIdentifier | null | undefined, index: number = 0): Texture | null {
+        return this.tryGet(sourceId, LightmapType.Lightmap, index);
+    }
+
+    tryGetSkybox(sourceId?: SourceIdentifier | null): Texture | null {
+        return this.tryGet(sourceId, LightmapType.Skybox, 0);
+    }
+
+    tryGetReflection(sourceId?: SourceIdentifier | null): Texture | null {
+        return this.tryGet(sourceId, LightmapType.Reflection, 0);
+    }
+
+    tryGet(sourceId: SourceIdentifier | undefined | null, type: LightmapType, index: number): Texture | null {
+        if (!sourceId) {
+            if (debugLightmap) console.warn("Missing source id");
+            return null;
+        }
+        const arr = this._lightmaps.get(sourceId)?.get(type) ?? null;
+        if (!arr?.length || arr.length <= index) return null;
+        return arr[index];
+    }
+
+}
+
+
+
+
+// all the chunks we can patch
+// console.log(THREE.ShaderChunk);
+// Unity: ambientOrLightmapUV.xy = v.uv1.xy * unity_LightmapST.xy + unity_LightmapST.zw; ambientOrLightmapUV.zw = 0;
+THREE.ShaderChunk.lights_fragment_maps = THREE.ShaderChunk.lights_fragment_maps.replace("vec4 lightMapTexel = texture2D( lightMap, vUv2 );", `
+
+    vec2 lUv = vUv2.xy * lightmapScaleOffset.xy + vec2(lightmapScaleOffset.z, (1. - (lightmapScaleOffset.y + lightmapScaleOffset.w)));
+    vec4 lightMapTexel = texture2D( lightMap, lUv);
+    // The range of RGBM lightmaps goes from 0 to 34.49 (5^2.2) in linear space, and from 0 to 5 in gamma space.
+    lightMapTexel.rgb *= lightMapTexel.a * 8.; // no idea where that "8" comes from... heuristically derived
+    lightMapTexel.a = 1.;
+    lightMapTexel = conv_sRGBToLinear(lightMapTexel);
+    `);
+
+THREE.ShaderChunk.lightmap_pars_fragment = `
+    #ifdef USE_LIGHTMAP
+        uniform sampler2D lightMap;
+        uniform float lightMapIntensity;
+        uniform vec4 lightmapScaleOffset;
+        
+        // took from threejs 05fc79cd52b79e8c3e8dec1e7dca72c5c39983a4
+        vec4 conv_sRGBToLinear( in vec4 value ) {
+            return vec4( mix( pow( value.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), value.rgb * 0.0773993808, vec3( lessThanEqual( value.rgb, vec3( 0.04045 ) ) ) ), value.a );
+        }
+    #endif
+    `;
+
+// When objects use Lightmaps in Unity, they already have IBL applied on the Lightmap,
+// so they shouldn't receive light probe lighting.
+// TODO: this gets difficult if there are additional real-time lightprobes added; we would need to exclude
+// exactly those that were active when lighting was baked... that's complicated!
+THREE.ShaderChunk.lights_fragment_begin = THREE.ShaderChunk.lights_fragment_begin.replace(
+    "irradiance += getLightProbeIrradiance( lightProbe, geometry.normal );", `
+#if defined(USE_LIGHTMAP)
+irradiance += 0.;
+#else
+irradiance += getLightProbeIrradiance( lightProbe, geometry.normal );
+#endif`);
+
+THREE.UniformsLib.lightmap["lightmapScaleOffset"] = { value: new THREE.Vector4(1, 1, 0, 0) };

package/src/engine/engine_loaders.ts

@@ -0,0 +1,26 @@
+
+import { Context } from "./engine_setup"
+import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js'
+import { DRACOLoader } from 'three/examples/jsm/loaders/DRACOLoader.js';
+import { KTX2Loader } from 'three/examples/jsm/loaders/KTX2Loader.js';
+
+let dracoLoader: DRACOLoader;
+let ktx2Loader: KTX2Loader;
+
+
+export function addDracoAndKTX2Loaders(loader: GLTFLoader, context : Context) {
+    if (!dracoLoader) {
+        dracoLoader = new DRACOLoader();
+        dracoLoader.setDecoderPath('./include/draco/');
+        dracoLoader.setDecoderConfig({ type: 'js' });
+    }
+    if (!ktx2Loader) {
+        ktx2Loader = new KTX2Loader();
+        ktx2Loader.setTranscoderPath('./include/ktx2/');
+        if (context.renderer)
+            ktx2Loader.detectSupport(context.renderer);
+    }
+
+    loader.setDRACOLoader(dracoLoader);
+    loader.setKTX2Loader(ktx2Loader);
+}

package/src/engine/engine_mainloop_utils.ts

@@ -0,0 +1,292 @@
+import { Context } from './engine_setup';
+import * as utils from "./engine_generic_utils";
+import * as constants from "./engine_constants";
+import { Behaviour, Component, GameObject } from '../engine-components/Component';
+import { getParam } from './engine_utils';
+
+const debug = getParam("debugnewscripts");
+
+// if some other script adds new scripts in onEnable or awake 
+// the original array should be cleared before processing it
+// so we use this copy buffer
+const new_scripts_buffer: any[] = [];
+
+export function processNewScripts(context: Context) {
+    if (context.new_scripts.length <= 0) return;
+    if (debug)
+        console.log("Register new components", context.new_scripts.length, context.alias ? ("element: " + context.alias) : "");
+
+    // if(new_scripts_post_setup_callbacks.length > 0) console.log(new_scripts_post_setup_callbacks);
+    if (context.new_scripts_pre_setup_callbacks.length > 0) {
+        for (const cb of context.new_scripts_pre_setup_callbacks) {
+            if (!cb) continue;
+            cb();
+        }
+        context.new_scripts_pre_setup_callbacks.length = 0;
+    }
+
+    // TODO: update all the code from above to use this logic
+    // basically code gen should add the scripts to new scripts
+    // and this code below should go into some util method
+    new_scripts_buffer.length = 0;
+    if (context.new_scripts.length > 0) {
+        new_scripts_buffer.push(...context.new_scripts);
+    }
+    context.new_scripts.length = 0;
+
+    // Check valid scripts and add all valid to the scripts array
+    for (let i = 0; i < new_scripts_buffer.length; i++) {
+        try {
+            const script: Behaviour = new_scripts_buffer[i];
+            if (script.destroyed) continue;
+            if (!script.gameObject) {
+                console.error("MISSING GAMEOBJECT - will ignore", script);
+                new_scripts_buffer.splice(i, 1);
+                i--;
+                continue;
+            }
+            script.context = context;
+            updateActiveInHierarchyWithoutEventCall(script.gameObject);
+            addScriptToArrays(script, context);
+        }
+        catch (err) {
+            console.error(err);
+            removeScriptFromContext(new_scripts_buffer[i], context);
+            new_scripts_buffer.splice(i, 1);
+            i--;
+        }
+    }
+
+    // Awake
+    for (let i = 0; i < new_scripts_buffer.length; i++) {
+        try {
+            const script: Behaviour = new_scripts_buffer[i];
+            if (script.destroyed) {
+                removeScriptFromContext(new_scripts_buffer[i], context);
+                new_scripts_buffer.splice(i, 1);
+                i--; continue;
+            }
+            // console.log(script, script.gameObject)
+            // TODO: we should not call awake on components with inactive gameobjects
+            if (script.__internalAwake !== undefined) {
+                if (!script.gameObject) {
+                    console.error("MISSING GAMEOBJECT", script, script.gameObject);
+                }
+                updateActiveInHierarchyWithoutEventCall(script.gameObject);
+                if (script.activeAndEnabled)
+                    utils.safeInvoke(script.__internalAwake.bind(script));
+            }
+        }
+        catch (err) {
+            console.error(err);
+            removeScriptFromContext(new_scripts_buffer[i], context);
+            new_scripts_buffer.splice(i, 1);
+            i--;
+        }
+    }
+
+    // OnEnable
+    for (let i = 0; i < new_scripts_buffer.length; i++) {
+        try {
+            const script: Behaviour = new_scripts_buffer[i];
+            if (script.destroyed) continue;
+            // console.log(script, script.enabled, script.activeAndEnabled);
+            if (script.enabled === false) continue;
+            updateActiveInHierarchyWithoutEventCall(script.gameObject);
+            if (script.activeAndEnabled === false) continue;
+            if (script.__internalEnable !== undefined) {
+                script.enabled = true;
+                utils.safeInvoke(script.__internalEnable.bind(script));
+            }
+        }
+        catch (err) {
+            console.error(err);
+            removeScriptFromContext(new_scripts_buffer[i], context);
+            new_scripts_buffer.splice(i, 1);
+            i--;
+        }
+    }
+
+    // Enqueue Start
+    for (let i = 0; i < new_scripts_buffer.length; i++) {
+        try {
+            const script = new_scripts_buffer[i];
+            if (script.destroyed) continue;
+            if (!script.gameObject) continue;
+            context.new_script_start.push(script);
+        }
+        catch (err) {
+            console.error(err);
+            removeScriptFromContext(new_scripts_buffer[i], context);
+            new_scripts_buffer.splice(i, 1);
+            i--;
+        }
+    }
+
+    // for (const script of new_scripts_buffer) {
+    //     if (script.destroyed) continue;
+    //     context.scripts.push(script);
+    // }
+    new_scripts_buffer.length = 0;
+
+    // if(new_scripts_post_setup_callbacks.length > 0) console.log(new_scripts_post_setup_callbacks);
+    for (const cb of context.new_scripts_post_setup_callbacks) {
+        if (cb)
+            cb();
+    }
+    context.new_scripts_post_setup_callbacks.length = 0;
+}
+
+export function processRemoveFromScene(script: Component) {
+    if (!script) return;
+    script.__internalDisable();
+    removeScriptFromContext(script, script.context);
+}
+
+export function processStart(context: Context) {
+    // Call start on scripts
+    for (let i = 0; i < context.new_script_start.length; i++) {
+        try {
+            const script = context.new_script_start[i];
+            if (script.destroyed) continue;
+            if (script.activeAndEnabled === false) continue;
+            // keep them in queue until script has started
+            // call awake if the script was inactive before
+            utils.safeInvoke(script.__internalAwake.bind(script));
+            utils.safeInvoke(script.__internalEnable.bind(script));
+            // now call start
+            utils.safeInvoke(script.__internalStart.bind(script));
+            context.new_script_start.splice(i, 1);
+            i--;
+        }
+        catch (err) {
+            console.error(err);
+            removeScriptFromContext(context.new_script_start[i], context);
+            context.new_script_start.splice(i, 1);
+            i--;
+        }
+    }
+}
+
+
+export function addScriptToArrays(script: any, context: Context) {
+    // TODO: not sure if this is ideal - maybe we should add a map if we have many scripts?
+    const index = context.scripts.indexOf(script);
+    if (index !== -1) return;
+    context.scripts.push(script);
+    if (script.earlyUpdate) context.scripts_earlyUpdate.push(script);
+    if (script.update) context.scripts_update.push(script);
+    if (script.lateUpdate) context.scripts_lateUpdate.push(script);
+    if (script.onBeforeRender) context.scripts_onBeforeRender.push(script);
+    if (script.onAfterRender) context.scripts_onAfterRender.push(script);
+}
+
+
+export function removeScriptFromContext(script: any, context: Context) {
+    removeFromArray(script, context.new_scripts);
+    removeFromArray(script, context.new_script_start);
+    removeFromArray(script, context.scripts);
+    removeFromArray(script, context.scripts_earlyUpdate);
+    removeFromArray(script, context.scripts_update);
+    removeFromArray(script, context.scripts_lateUpdate);
+    removeFromArray(script, context.scripts_onBeforeRender);
+    removeFromArray(script, context.scripts_onAfterRender);
+    context.stopAllCoroutinesFrom(script);
+}
+
+function removeFromArray(script: any, array: any[]) {
+    const index = array.indexOf(script);
+    if (index >= 0) array.splice(index, 1);
+}
+
+const previousActiveMap: { [key: string]: boolean } = {};
+const previousActiveInHierarchyMap: { [key: string]: boolean } = {};
+
+export function updateIsActive() {
+    if (!Context.Current) {
+        console.trace("Invalid call - no current context.");
+        return;
+    }
+    updateIsActiveInHierarchyRecursiveRuntime(Context.Current.scene, Context.Current.scene.visible, true);
+}
+
+function updateIsActiveInHierarchyRecursiveRuntime(go: THREE.Object3D, activeInHierarchy: boolean, allowEventCall: boolean) {
+    let activeStateChanged: boolean = false;
+
+    const active = GameObject.isActiveSelf(go);
+    // if (activeInHierarchy) {
+    //     const prevActive = previousActiveMap[go.uuid];
+    //     if (prevActive !== undefined) {
+    //         if (prevActive !== active) {
+    //             activeStateChanged = true;
+    //             if (allowEventCall) {
+    //                 perComponent(go, comp => {
+    //                     if (active) {
+    //                         utils.safeInvoke(comp.__internalAwake.bind(comp));
+    //                         comp.onEnable();
+    //                     }
+    //                     else comp.onDisable();
+    //                 });
+    //             }
+    //         }
+    //     }
+    // }
+    previousActiveMap[go.uuid] = active;
+
+
+    if (activeInHierarchy) activeInHierarchy = GameObject.isActiveSelf(go);
+    go[constants.activeInHierarchyFieldName] = activeInHierarchy;
+
+    // only raise events here if we didnt call enable etc already
+    if (!activeStateChanged) {
+        const prevActiveInHierarchy = previousActiveInHierarchyMap[go.uuid];
+        if (prevActiveInHierarchy !== undefined) {
+            if (prevActiveInHierarchy !== activeInHierarchy) {
+                if (allowEventCall) {
+                    perComponent(go, comp => {
+                        if (activeInHierarchy) {
+                            utils.safeInvoke(comp.__internalAwake.bind(comp));
+                            comp.onEnable();
+                        }
+                        else comp.onDisable();
+                    });
+                }
+            }
+        }
+    }
+    previousActiveInHierarchyMap[go.uuid] = activeInHierarchy;
+
+    if (go.children) {
+        for (const ch of go.children) {
+            updateIsActiveInHierarchyRecursiveRuntime(ch, activeInHierarchy, allowEventCall);
+        }
+    }
+}
+
+export function updateActiveInHierarchyWithoutEventCall(go: THREE.Object3D) {
+    let activeInHierarchy = true;
+    let current: THREE.Object3D | null = go;
+    let foundScene: boolean = false;
+    while (current) {
+        if (!current) break;
+        if (current.type === "Scene") foundScene = true;
+        if (!GameObject.isActiveSelf(current)) {
+            activeInHierarchy = false;
+            break;
+        }
+        current = current.parent;
+    }
+    if (!go) {
+        console.error("GO is null");
+        return;
+    }
+    go[constants.activeInHierarchyFieldName] = activeInHierarchy && foundScene;
+}
+
+function perComponent(go: THREE.Object3D, evt: (comp: Component) => void) {
+    if (go.userData?.components) {
+        for (const comp of go.userData.components) {
+            evt(comp);
+        }
+    }
+}

package/src/engine/engine_math.ts

@@ -0,0 +1,43 @@
+
+
+
+class MathHelper {
+    random(): number {
+        return Math.random();
+    }
+    clamp(value, min, max) {
+
+        if (value < min) {
+            return min;
+        }
+        else if (value > max) {
+            return max;
+        }
+
+        return value;
+    }
+    clamp01(value) {
+        return this.clamp(value, 0, 1);
+    }
+    lerp(value1, value2, amount) {
+        amount = amount < 0 ? 0 : amount;
+        amount = amount > 1 ? 1 : amount;
+        return value1 + (value2 - value1) * amount;
+    }
+    moveTowards(value1, value2, amount) {
+        value1 += amount;
+        if (amount < 0 && value1 < value2) value1 = value2;
+        else if (amount > 0 && value1 > value2) value1 = value2;
+        return value1;
+    }
+    toDegrees(radians) {
+        return radians * 180 / Math.PI;
+    }
+    toRadians(degrees) {
+        return degrees * Math.PI / 180;
+    }
+};
+
+const Mathf = new MathHelper();
+
+export { Mathf };