@needle-tools/engine 2.24.0-pre

package/src/engine/extensions/NEEDLE_lighting_settings.ts

@@ -0,0 +1,161 @@
+import { AmbientLight, Color, HemisphereLight } from "three";
+import { GLTF, GLTFLoaderPlugin, GLTFParser } from "three/examples/jsm/loaders/GLTFLoader";
+import { SourceIdentifier } from "../engine_gltf";
+import { Behaviour, GameObject } from "../../engine-components/Component";
+import { AmbientMode, DefaultReflectionMode } from "../engine_rendererdata";
+import { LightmapType } from "./NEEDLE_lightmaps";
+import { getParam } from "../engine_utils";
+import { Context } from "../engine_setup";
+import { LightProbe } from "three";
+
+export const EXTENSION_NAME = "NEEDLE_lighting_settings";
+const debug = getParam("debugenvlight");
+
+export type LightingSettings = {
+    ambientMode: AmbientMode;
+    ambientIntensity: number,
+    ambientLight: number[],
+    ambientTrilight: Array<number[]>,
+    environmentReflectionSource: DefaultReflectionMode;
+}
+
+export class NEEDLE_lighting_settings implements GLTFLoaderPlugin {
+
+    get name(): string {
+        return EXTENSION_NAME;
+    }
+
+    private parser: GLTFParser;
+    private sourceId: SourceIdentifier;
+    private context: Context;
+
+    constructor(parser: GLTFParser, sourceId: SourceIdentifier, context: Context) {
+        this.parser = parser;
+        this.sourceId = sourceId;
+        this.context = context;
+    }
+
+    afterRoot(_result: GLTF): Promise<void> | null {
+
+        const extensions = this.parser.json.extensions;
+        if (extensions) {
+            const ext: LightingSettings = extensions[EXTENSION_NAME];
+            if (ext) {
+                if (debug)
+                    console.log(ext);
+                // add a component to the root of the scene
+                const settings = GameObject.addNewComponent(_result.scene, SceneLightSettings, false);
+                settings.sourceId = this.sourceId;
+                settings.ambientIntensity = ext.ambientIntensity;
+                settings.ambientLight = new Color().fromArray(ext.ambientLight);
+                if (Array.isArray(ext.ambientTrilight))
+                    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;
+    }
+
+}
+
+// exists once per gltf scene root (if it contains reflection)
+// when enabled it does currently automatically set the reflection
+// this might not be desireable
+export class SceneLightSettings extends Behaviour {
+
+    ambientMode: AmbientMode = AmbientMode.Skybox;
+    ambientLight?: Color;
+    ambientTrilight?: Color[];
+    ambientIntensity: number = 1;
+    environmentReflectionSource: DefaultReflectionMode = DefaultReflectionMode.Skybox;
+
+    private _hasReflection: boolean = false;
+    private _ambientLightObj?: AmbientLight;
+    // used when skybox is used to support ambient intensity for "non custom shaders"
+    private _lightProbeObj?: LightProbe;
+
+    awake() {
+        if (this.sourceId) {
+            const type = this.environmentReflectionSource === DefaultReflectionMode.Skybox ? LightmapType.Skybox : LightmapType.Reflection;
+            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);
+        }
+
+        if (debug) {
+            window.addEventListener("keydown", evt => {
+                switch (evt.key) {
+                    case "l":
+                        this.enabled = !this.enabled;
+                        break;
+                }
+            });
+        }
+    }
+
+    onEnable() {
+        const isActive = this.context.mainCameraComponent?.sourceId === this.sourceId;
+        if (debug)
+            console.log("enable", this.sourceId, isActive, this, this.context.mainCameraComponent?.sourceId);
+        if (!isActive) {
+            // this.enabled = false;
+            // return;
+        }
+        if (this.ambientMode == AmbientMode.Flat) {
+            if (this.ambientLight) {
+                this._ambientLightObj = new AmbientLight(this.ambientLight, Math.PI * this.ambientIntensity);
+            }
+            if (this._ambientLightObj) {
+                this.gameObject.add(this._ambientLightObj)
+            }
+            if (this._lightProbeObj) this._lightProbeObj.removeFromParent();
+        }
+        else if (this.ambientMode === AmbientMode.Trilight) {
+            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)
+            }
+        }
+        else {
+            if (this._ambientLightObj)
+                this._ambientLightObj.removeFromParent();
+
+            // create light probe object
+            if (!this._lightProbeObj) {
+                if (this.sourceId) {
+                    this.context.rendererData.getSceneLightingData(this.sourceId).then(data => {
+                        if (debug)
+                            console.log(data);
+                        if (!data) return;
+                        this._lightProbeObj = data.lightProbe;
+                        if (this.enabled && !this.destroyed && this._lightProbeObj) {
+                            this.scene.add(this._lightProbeObj);
+                        }
+                    });
+                }
+            }
+            else {
+                if (this.enabled && this.destroyed && this._lightProbeObj) {
+                    this.scene.add(this._lightProbeObj);
+                }
+            }
+        }
+
+        if (this.sourceId)
+            this.context.rendererData.enableReflection(this.sourceId);
+
+    }
+
+    onDisable() {
+        if (debug)
+            console.log("disable", this.sourceId, this);
+        if (this._lightProbeObj) this._lightProbeObj.removeFromParent();
+        if (this.sourceId)
+            this.context.rendererData.disableReflection();
+    }
+}

package/src/engine/extensions/NEEDLE_lightmaps.ts

@@ -0,0 +1,93 @@
+import { ILightDataRegistry } from "../engine_lightdata";
+import { FloatType, HalfFloatType, sRGBEncoding, Texture } from "three";
+import { GLTF, GLTFLoaderPlugin, GLTFParser } from "three/examples/jsm/loaders/GLTFLoader";
+import { SourceIdentifier } from "../engine_gltf";
+import { resolveReferences } from "./extension_utils";
+import { getParam } from "../engine_utils";
+
+// the lightmap extension is aimed to also export export skyboxes and custom reflection maps
+// should we rename it?
+// should we split it into multiple extensions?
+
+export const EXTENSION_NAME = "NEEDLE_lightmaps";
+const debug = getParam("debuglightmapsextension");
+
+export enum LightmapType {
+    Lightmap = 0,
+    Skybox = 1,
+    Reflection = 2,
+}
+
+declare type LightmapExtension = {
+    textures : Array<LightmapInfo>;
+}
+
+declare type LightmapInfo = {
+    type: LightmapType,
+    pointer?: string,
+    index?: number;
+}
+
+export class NEEDLE_lightmaps implements GLTFLoaderPlugin {
+
+    get name(): string {
+        return EXTENSION_NAME;
+    }
+
+    private parser: GLTFParser;
+    private registry: ILightDataRegistry;
+    private source: SourceIdentifier;
+
+    constructor(parser: GLTFParser, reg: ILightDataRegistry, source: SourceIdentifier) {
+        this.parser = parser;
+        this.registry = reg;
+        this.source = source;
+    }
+
+    afterRoot(_result: GLTF): Promise<void> | null {
+
+        const extensions = this.parser.json.extensions;
+        if (extensions) {
+            const ext: LightmapExtension = extensions[EXTENSION_NAME];
+            if (ext) {
+                const arr = ext.textures;
+                if (!arr.length) {
+                    return null;
+                }
+                if (debug)
+                    console.log(ext);
+
+                return new Promise(async (res, _rej) => {
+                    const dependencies: Array<Promise<any>> = [];
+                    for (const entry of arr) {
+                        if (entry.pointer) {
+                            const res = resolveReferences(this.parser, entry.pointer).then(res => {
+                                const tex: Texture = res as unknown as Texture;
+                                if (tex?.isTexture) {
+                                    if (!this.registry)
+                                        console.log(LightmapType[entry.type], entry.pointer, tex);
+                                    else {
+                                        // TODO this is most likely wrong for floating point textures
+                                        if (entry.type !== LightmapType.Lightmap)
+                                            tex.encoding = sRGBEncoding;
+
+                                        // not sure why, but seems EXR-loaded float textures need to be flipped
+                                        if(tex.type == FloatType || tex.type == HalfFloatType)
+                                            tex.flipY = true;
+
+                                        this.registry.registerTexture(this.source, entry.type, tex, entry.index);
+                                    }
+                                }
+                            });
+                            dependencies.push(res);
+                        }
+                    }
+                    await Promise.all(dependencies);
+                    res();
+                });
+            }
+        }
+        return null;
+    }
+
+}

package/src/engine/extensions/NEEDLE_persistent_assets.ts

@@ -0,0 +1,76 @@
+import { resolveReferences } from "./extension_utils";
+import { GLTF, GLTFLoaderPlugin, GLTFParser } from "three/examples/jsm/loaders/GLTFLoader";
+import { IExtensionReferenceResolver } from "./extension_resolver";
+import { debugExtension } from "../engine_default_parameters";
+import { TypeStore } from "../engine_typestore";
+
+export const EXTENSION_NAME = "NEEDLE_persistent_assets";
+
+export function isPersistentAsset(asset: any): boolean {
+    return asset?.___persistentAsset === true;
+}
+
+declare type PersistentAsset = {
+    assets: Array<any>
+};
+
+export class NEEDLE_persistent_assets implements GLTFLoaderPlugin, IExtensionReferenceResolver {
+
+    get name(): string {
+        return EXTENSION_NAME;
+    }
+
+    private parser: GLTFParser;
+
+    constructor(parser: GLTFParser) {
+        this.parser = parser;
+    }
+
+
+    async afterRoot(_result: GLTF): Promise<void> {
+        if (!this.parser?.json?.extensions) return;
+        const ext = this.parser.json.extensions[EXTENSION_NAME] as PersistentAsset;
+        if (!ext) return;
+        if (debugExtension)
+            console.log(ext);
+        const promises = new Array<Promise<any>>();
+        for (const e of ext?.assets) {
+            const p = resolveReferences(this.parser, e);
+            if (p) {
+                promises.push(p);
+            }
+        }
+        await Promise.all(promises);
+    }
+
+    resolve(parser: GLTFParser, path: string): Promise<void> | null | any {
+        const index = Number.parseInt(path);
+        if (index >= 0) {
+            if (debugExtension)
+                console.log(path);
+            const ext = parser.json.extensions[EXTENSION_NAME] as PersistentAsset;
+            if (ext) {
+                const asset = ext?.assets[index];
+                if (asset) {
+                    if (typeof asset === "object") {
+                        asset.___persistentAsset = true;
+                        const assetTypeInfo = asset["__type"];
+                        if (assetTypeInfo) {
+                            const type = TypeStore.get(assetTypeInfo);
+                            if (type) {
+                                // TODO: assign types here
+                                // console.log(assetTypeInfo, type);
+                                // const instance = new type(asset);
+                                // assign(instance, asset);
+                                // ext.assets[index] = instance;
+                                // return instance;
+                            }
+                        }
+                    }
+                }
+                return asset;
+            }
+        }
+        return null;
+    }
+}

package/src/engine/extensions/NEEDLE_render_objects.ts

@@ -0,0 +1,197 @@
+
+import { SourceIdentifier } from "../engine_gltf";
+import { GLTF, GLTFLoaderPlugin, GLTFParser } from "three/examples/jsm/loaders/GLTFLoader";
+import { Behaviour } from "../../engine-components/Component";
+import { Renderer } from "../../engine-components/Renderer";
+import {
+    // stencil funcs
+    NeverStencilFunc,
+    LessStencilFunc,
+    EqualStencilFunc,
+    LessEqualStencilFunc,
+    GreaterStencilFunc,
+    NotEqualStencilFunc,
+    GreaterEqualStencilFunc,
+    AlwaysStencilFunc,
+    // stencil ops
+    ZeroStencilOp,
+    KeepStencilOp,
+    ReplaceStencilOp,
+    IncrementStencilOp,
+    DecrementStencilOp,
+    IncrementWrapStencilOp,
+    DecrementWrapStencilOp,
+    InvertStencilOp,
+} from "three";
+import { getParam } from "../engine_utils";
+
+const debug = getParam("debugstencil");
+
+function matchesLayer(stencilLayer: number, comp: Behaviour): boolean {
+    return (stencilLayer & 1 << comp.layer) != 0;
+}
+
+
+declare type StencilSettingsModel = {
+    name: string;
+    event: number;
+    index: number;
+    queue: number;
+    layer: number;
+    value: number;
+    compareFunc: number;
+    passOp: number;
+    failOp: number;
+    zFailOp: number;
+}
+
+export class NEEDLE_render_objects implements GLTFLoaderPlugin {
+
+    private static stencils: { [key: string]: StencilSettingsModel[] } = {};
+
+    static applyStencil(obj?: Renderer | null) {
+        if (!obj) return;
+        const source = obj.sourceId;
+        if (debug)
+            console.log(source, NEEDLE_render_objects.stencils);
+        if (!source) return;
+        const settings = NEEDLE_render_objects.stencils[source];
+        if (!settings) return;
+        for (let i = settings.length - 1; i >= 0; i--) {
+            const stencil: StencilSettingsModel = settings[i];
+            if (matchesLayer(stencil.layer, obj)) {
+                if (debug)
+                    console.log(stencil);
+                const mat = obj.material?.clone();
+                if (mat) {
+                    obj.material = mat;
+                    // you can have 50 renderer features per event until this breaks
+                    obj.gameObject.renderOrder = stencil.event * 1000 + stencil.index * 50;
+
+                    mat.stencilWrite = true;
+                    mat.stencilWriteMask = 255;
+                    mat.stencilFuncMask = 255;
+                    mat.stencilRef = stencil.value;
+                    mat.stencilFunc = stencil.compareFunc;
+                    mat.stencilZPass = stencil.passOp;
+                    mat.stencilFail = stencil.failOp;
+                    mat.stencilZFail = stencil.zFailOp;
+                }
+                break;
+            }
+        }
+    }
+
+
+    private parser: GLTFParser;
+    private source: SourceIdentifier;
+
+    constructor(parser: GLTFParser, source: SourceIdentifier) {
+        this.parser = parser;
+        this.source = source;
+    }
+
+    afterRoot(_result: GLTF): Promise<void> | null {
+
+        const extensions = this.parser.json.extensions;
+        if (extensions) {
+            const ext = extensions[EXTENSION_NAME];
+            if (ext) {
+                if (debug)
+                    console.log(ext);
+                const stencils = ext.stencil;
+                if (stencils && Array.isArray(stencils)) {
+                    for (const stencil of stencils) {
+                        const obj: StencilSettingsModel = { ...stencil };
+                        obj.compareFunc = ToThreeCompareFunction(obj.compareFunc);
+                        obj.passOp = ToThreeStencilOp(obj.passOp);
+                        obj.failOp = ToThreeStencilOp(obj.failOp);
+                        obj.zFailOp = ToThreeStencilOp(obj.zFailOp);
+
+                        if (!NEEDLE_render_objects.stencils[this.source])
+                            NEEDLE_render_objects.stencils[this.source] = [];
+                        NEEDLE_render_objects.stencils[this.source].push(obj);
+                    }
+                }
+            }
+        }
+
+        return null;
+    }
+
+}
+
+
+
+
+
+enum StencilOp {
+    Keep = 0,
+    Zero = 1,
+    Replace = 2,
+    IncrementSaturate = 3,
+    DecrementSaturate = 4,
+    Invert = 5,
+    IncrementWrap = 6,
+    DecrementWrap = 7,
+}
+
+enum CompareFunction {
+    Disabled,
+    Never,
+    Less,
+    Equal,
+    LessEqual,
+    Greater,
+    NotEqual,
+    GreaterEqual,
+    Always,
+}
+
+function ToThreeStencilOp(op: StencilOp): number {
+    switch (op) {
+        case StencilOp.Keep:
+            return KeepStencilOp;
+        case StencilOp.Zero:
+            return ZeroStencilOp;
+        case StencilOp.Replace:
+            return ReplaceStencilOp;
+        case StencilOp.IncrementSaturate:
+            return IncrementStencilOp;
+        case StencilOp.DecrementSaturate:
+            return DecrementStencilOp;
+        case StencilOp.IncrementWrap:
+            return IncrementWrapStencilOp;
+        case StencilOp.DecrementWrap:
+            return DecrementWrapStencilOp;
+        case StencilOp.Invert:
+            return InvertStencilOp;
+    }
+    return 0;
+}
+
+function ToThreeCompareFunction(func: CompareFunction): number {
+    switch (func) {
+        case CompareFunction.Never:
+            return NeverStencilFunc;
+        case CompareFunction.Less:
+            return LessStencilFunc;
+        case CompareFunction.Equal:
+            return EqualStencilFunc;
+        case CompareFunction.LessEqual:
+            return LessEqualStencilFunc;
+        case CompareFunction.Greater:
+            return GreaterStencilFunc;
+        case CompareFunction.NotEqual:
+            return NotEqualStencilFunc;
+        case CompareFunction.GreaterEqual:
+            return GreaterEqualStencilFunc;
+        case CompareFunction.Always:
+            return AlwaysStencilFunc;
+    }
+    return 0;
+}
+
+
+export const EXTENSION_NAME = "NEEDLE_render_objects";
+