@needle-tools/engine 2.24.0-pre

package/src/engine/extensions/extension_utils.ts

@@ -0,0 +1,138 @@
+import { IExtensionReferenceResolver } from "./extension_resolver";
+import { GLTFParser } from "three/examples/jsm/loaders/GLTFLoader";
+import { debugExtension } from "../engine_default_parameters";
+import { getParam } from "../engine_utils";
+
+const debug = getParam("debugresolvedependencies");
+
+declare type DependencyInfo = {
+    prefix: string,
+    dependencyName: string,
+}
+
+const defaultDependencies = [
+    { prefix: "nodes/", dependencyName: "node" },
+    { prefix: "meshes/", dependencyName: "mesh" },
+    { prefix: "materials/", dependencyName: "material" },
+    { prefix: "textures/", dependencyName: "texture" },
+    { prefix: "animations/", dependencyName: "animation" }
+]
+
+export async function resolveReferences(parser: GLTFParser, obj) {
+    if(debug) console.log(parser, obj);
+    const arr: Promise<void>[] = [];
+    internalResolve(defaultDependencies, parser, obj, arr);
+    const res = await Promise.all(arr);
+    if (typeof obj === "string" && res.length === 1) return res[0];
+    return res;
+}
+
+
+function internalResolve(paths: DependencyInfo[], parser: GLTFParser, obj, promises: Promise<void>[]) {
+    if (typeof obj === "object" && obj !== undefined && obj !== null) {
+        for (const key of Object.keys(obj)) {
+            const val = obj[key];
+            // handle json pointer in string variable
+            if (typeof val === "string") {
+                const ext = resolveExtension(parser, val);
+                if (ext !== null) {
+                    if (typeof ext.then === "function")
+                        promises.push(ext.then(res => obj[key] = res));
+                    else obj[key] = ext;
+                }
+                else {
+                    // e.g. prefix = "materials/";
+                    for (const dep of paths) {
+                        const index = tryGetIndex(dep.prefix, val);
+                        if (index >= 0) {
+                            // e.g. dependencyName = "material"
+                            if (debug) console.log(dep, index, dep.dependencyName);
+                            promises.push(parser?.getDependency(dep.dependencyName, index).then(res => {
+                                obj[key] = res;
+                                return res;
+                            }));
+                            break;
+                        }
+                    }
+                }
+            }
+            // handle json pointers in arrays
+            else if (Array.isArray(val)) {
+                for (let i = 0; i < val.length; i++) {
+                    const entry = val[i];
+                    const ext = resolveExtension(parser, entry);
+                    if (ext !== null) {
+                        if (typeof ext.then === "function")
+                            promises.push(ext.then(res => val[i] = res));
+                        else val[i] = ext;
+                        continue;
+                    }
+                    for (const dep of paths) {
+                        const index = tryGetIndex(dep.prefix, entry);
+                        if (index >= 0) {
+                            if (debug) console.log(dep, index, dep.dependencyName);
+                            promises.push(parser?.getDependency(dep.dependencyName, index).then(res => val[i] = res));
+                            break;
+                        }
+                    }
+                    // recurse
+                    if (typeof entry === "object") {
+                        internalResolve(paths, parser, entry, promises);
+                    }
+                }
+            }
+            // recurse
+            else if (typeof val === "object") {
+                internalResolve(paths, parser, val, promises);
+            }
+        }
+    }
+    else if (typeof obj === "string") {
+        tryResolveDependency(paths, parser, obj, promises);
+    }
+}
+
+
+const rootExtensionPrefix = "extensions/";
+function resolveExtension(parser: GLTFParser, str): Promise<void> | null {
+    if (parser && parser.plugins && typeof str === "string" && str.startsWith(rootExtensionPrefix)) {
+        let name = str.substring(rootExtensionPrefix.length);
+        const endIndex = name.indexOf("/");
+        if (endIndex >= 0) name = name.substring(0, endIndex);
+        const ext = parser.plugins[name] as IExtensionReferenceResolver;
+        if (debugExtension)
+            console.log(name, ext);
+        if (typeof ext?.resolve === "function") {
+            const path = str.substring(rootExtensionPrefix.length + name.length + 1);
+            return ext.resolve(parser, path);
+        }
+    }
+    return null;
+}
+
+function tryResolveDependency(paths: DependencyInfo[], parser: GLTFParser, str: string, promises: Promise<void>[]): boolean {
+    for (const dep of paths) {
+        const index = tryGetIndex(dep.prefix, str);
+        if (index >= 0) {
+            // e.g. dependencyName = "material"
+            if (debug) console.log(dep, index, dep.dependencyName);
+            promises.push(parser?.getDependency(dep.dependencyName, index).then(res => {
+                return res;
+            }));
+            return true;
+        }
+    }
+    return false;
+}
+
+function tryGetIndex(prefix: string, str: string): number {
+
+    if (typeof str === "string" && str.startsWith(prefix)) {
+        const part = str.substring(prefix.length);
+        const index = Number.parseInt(part);
+        if (index >= 0) {
+            return index;
+        }
+    }
+    return -1;
+}

package/src/engine/extensions/extensions.ts

@@ -0,0 +1,49 @@
+import { NEEDLE_techniques_webgl } from "./NEEDLE_techniques_webgl";
+import { GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader";
+import { NEEDLE_components } from "./NEEDLE_components";
+import { EXT_texture_exr } from "./EXT_texture_exr";
+import { NEEDLE_gameobject_data } from "./NEEDLE_gameobject_data";
+// import { NEEDLE_timeline } from "./NEEDLE_timeline";
+// import { NEEDLE_animator_controller } from "./NEEDLE_animator_controller";
+import { NEEDLE_persistent_assets } from "./NEEDLE_persistent_assets";
+// import { KHR_animation_pointer } from "./KHR_animation_pointer";
+import { NEEDLE_lightmaps } from "../extensions/NEEDLE_lightmaps";
+import { SourceIdentifier } from "../engine_gltf";
+import { Context } from "../engine_setup";
+import { NEEDLE_lighting_settings } from "./NEEDLE_lighting_settings";
+import { NEEDLE_render_objects } from "./NEEDLE_render_objects";
+import { NEEDLE_deferred_texture } from "./NEEDLE_deferred_texture";
+
+export function registerComponentExtension(loader: GLTFLoader): NEEDLE_components {
+    const ext = new NEEDLE_components();
+    loader.register(p => {
+        ext.parser = p;
+        return ext;
+    });
+    return ext;
+}
+
+class PointerResolver {
+    resolvePath(path: string) {
+        if (path.includes('/extensions/builtin_components/'))
+            path = path.replace('/extensions/builtin_components/', '/userData/components/');
+
+        return path;
+    }
+}
+
+export function registerExtensions(loader: GLTFLoader, context: Context, sourceId: SourceIdentifier) {
+    loader.register(p => new NEEDLE_gameobject_data(p));
+    loader.register(p => new NEEDLE_persistent_assets(p));
+    loader.register(p => new NEEDLE_lightmaps(p, context.lightmaps, sourceId));
+    loader.register(p => new NEEDLE_lighting_settings(p, sourceId, context));
+    loader.register(p => new NEEDLE_techniques_webgl(p, sourceId));
+    loader.register(p => new NEEDLE_render_objects(p, sourceId));
+    loader.register(p => new NEEDLE_deferred_texture(p, sourceId, context));
+    loader.register(p => new EXT_texture_exr(p));
+
+    const setPointerResolverFunction = loader["setAnimationPointerResolver"];
+    if (typeof setPointerResolverFunction === "function")
+        setPointerResolverFunction.bind(loader)(new PointerResolver());
+
+}

package/src/engine/shaders/shaderData.ts

@@ -0,0 +1,68 @@
+
+
+
+export class ShaderData {
+    programs: Array<ShaderProgram> = [];
+    shaders: Array<Shader> = [];
+    techniques: Array<Technique> = [];
+}
+
+export class ShaderProgram {
+    vertexShader: number | undefined;
+    fragmentShader: number | undefined;
+}
+
+export enum ShaderType {
+
+    Fragment = 35632,
+    Vertex = 35633,
+}
+
+export class Shader {
+    name: string | undefined;
+    type: ShaderType | undefined;
+    uri: string | null | undefined;
+    code: string | null | undefined;
+}
+
+export class Technique {
+    program: number | undefined;
+    attributes: Map<string, ShaderAttribute> = new Map();;
+    uniforms: Map<string, ShaderUniform> = new Map();
+}
+
+export class ShaderAttribute {
+    semantic: string | undefined;
+}
+
+export class ShaderUniform {
+    name: string = "";
+    type: UniformType | undefined;
+    semantic: string | undefined;
+    count : number = 0;
+    node : number = 0;
+}
+
+
+
+export enum UniformType {
+    INT = 5124,
+    FLOAT = 5126,
+    FLOAT_VEC2 = 35664,
+    FLOAT_VEC3 = 35665,
+    FLOAT_VEC4 = 35666,
+    INT_VEC2 = 35667,
+    INT_VEC3 = 35668,
+    INT_VEC4 = 35669,
+    BOOL = 35670, // exported as int
+    BOOL_VEC2 = 35671,
+    BOOL_VEC3 = 35672,
+    BOOL_VEC4 = 35673,
+    FLOAT_MAT2 = 35674, // exported as vec2[2]
+    FLOAT_MAT3 = 35675, // exported as vec3[3]
+    FLOAT_MAT4 = 35676, // exported as vec4[4]
+    SAMPLER_2D = 35678,
+    SAMPLER_3D = 35680, // added, not in the proposed extension
+    SAMPLER_CUBE = 35681, // added, not in the proposed extension
+    UNKNOWN = 0,
+}

package/src/engine/tests/simulate_avatars.ts

@@ -0,0 +1,2 @@
+
+// TODO

package/src/engine/tests/test_utils.ts

@@ -0,0 +1,63 @@
+
+import * as utils from "../engine_utils";
+import { noVoip } from "../../engine-components/Voip";
+
+
+export function detect_run_tests(){
+    const count = (utils.getParam("testwindowcount") || 0) as number;
+    if(count && count > 0){
+        spawnWindows(count);
+    }
+}
+
+export function spawnWindows(count: number): Window[] | null {
+
+    if(utils.getParam("testwindow")) return null;
+
+    const url = new URL(window.location.href);
+    utils.setOrAddParamsToUrl(url.searchParams, noVoip, 1);
+    utils.setOrAddParamsToUrl(url.searchParams, "testwindow", 1);
+    const str = url.toString();
+
+    const windows : Window[] = [];
+
+    window.onbeforeunload = () =>{
+        for(const w of windows) w.close(); 
+    }
+
+    const spacing = .05;
+    const size = 128;// (Math.min(window.innerWidth, window.innerHeight) / Math.sqrt(count)) * (1-spacing);
+    let x = 0;
+    let y = 0;
+    for (let i = 0; i < count; i++) {
+
+        if ((x * size + size*.01) >= window.innerWidth) {
+            y += 1;
+            x = 0;
+        }
+        const px = x * (size * (1+spacing)) + window.screenLeft;
+        const py = y * (size * (1+spacing)) + window.screenTop + 90 + 60 * y; 
+        x += 1;
+
+        // console.log(size, px, py);
+        const testWindow = window.open(str, "test window " + i, `popup=yes width=${size} height=${size} top=${py} left=${px}`);
+
+        if(!testWindow){
+            console.warn("Failed to open window");
+            continue;
+        }
+        windows.push(testWindow);
+        testWindow.onload = () => {
+            testWindow.onbeforeunload = () => {
+                for (let i = 0; i < windows.length; i++) {
+                    const w = windows[i];
+                    if (w === testWindow) continue;
+                    w.close();
+                }
+                windows.length = 0;
+            }
+        }
+    }
+
+    return windows;
+}

package/src/engine-components/AlignmentConstraint.ts

@@ -0,0 +1,33 @@
+import { Behaviour, GameObject } from "./Component";
+import * as utils from "./../engine/engine_three_utils";
+import * as THREE from "three";
+
+export class AlignmentConstraint extends Behaviour {
+
+    private from!: GameObject;
+    private to!: GameObject;
+    private width: number = 0;
+    private centered: boolean = true;
+
+    private _centerPos!: THREE.Vector3;
+
+    awake(): void {
+        this._centerPos = new THREE.Vector3();
+    }
+
+    update() {
+        if (!this.from || !this.to) return;
+        
+        const fromWorldPos = utils.getWorldPosition(this.from).clone();
+        const toWorldPos = utils.getWorldPosition(this.to).clone();
+        const dist = fromWorldPos.distanceTo(toWorldPos);
+        
+        this._centerPos.copy(fromWorldPos);
+        this._centerPos.add(toWorldPos);
+        this._centerPos.multiplyScalar(0.5);
+
+        utils.setWorldPosition(this.gameObject, this.centered ? this._centerPos : fromWorldPos);
+        this.gameObject.lookAt(utils.getWorldPosition(this.to).clone());
+        this.gameObject.scale.set(this.width, this.width, dist);
+    }
+}

package/src/engine-components/Animation.ts

@@ -0,0 +1,282 @@
+import { Behaviour } from "./Component";
+import * as THREE from 'three'
+import { AnimationAction, AnimationClip } from "three";
+import { MixerEvent } from "./Animator";
+import { InstancingUtil } from "./Renderer";
+import { serializeable } from "../engine/engine_serialization_decorator";
+
+export declare class PlayOptions {
+    fadeDuration?: number;
+    loop?: boolean;
+    exclusive?: boolean;
+    startTime?: number;
+    endTime?: number;
+    clampWhenFinished?: boolean;
+}
+
+export class Animation extends Behaviour {
+
+    @serializeable()
+    playAutomatically: boolean = true;
+    @serializeable()
+    randomStartTime: boolean = true;
+
+    private _tempAnimationClipBeforeGameObjectExisted: AnimationClip | null = null;
+    get clip(): AnimationClip | null {
+        return this.animations?.length ? this.animations[0] : null;
+    }
+    set clip(val: AnimationClip | null) {
+        if (!this.gameObject) {
+            this._tempAnimationClipBeforeGameObjectExisted = val;
+            return;
+        }
+        if (!val) return;
+        if (!this.gameObject.animations) this.gameObject.animations = [];
+        this.gameObject.animations.push(val);
+    }
+
+    set animations(animations: THREE.AnimationClip[]) {
+        this.gameObject.animations = animations;
+    }
+
+    get animations(): THREE.AnimationClip[] {
+        return this.gameObject.animations;
+    }
+    /**
+     * @deprecated Currently unsupported
+     */
+    get currentAction(): THREE.AnimationAction | null {
+        return this._currentActions[0];
+    }
+
+    /**
+     * @deprecated Currently unsupported
+     */
+    get currentActions(): THREE.AnimationAction[] {
+        return this._currentActions;
+    }
+
+    private mixer: THREE.AnimationMixer | undefined = undefined;
+    get actions(): Array<THREE.AnimationAction> {
+        return this._actions;
+    }
+    set actions(val: Array<THREE.AnimationAction>) {
+        this._actions = val;
+    }
+    private _actions: Array<THREE.AnimationAction> = [];
+
+    // private _currentAction: THREE.AnimationAction | null = null;
+
+    private _currentActions: THREE.AnimationAction[] = [];
+    private _handles: AnimationHandle[] = [];
+
+    awake() {
+        if (this._tempAnimationClipBeforeGameObjectExisted) {
+            this.clip = this._tempAnimationClipBeforeGameObjectExisted;
+            this._tempAnimationClipBeforeGameObjectExisted = null;
+        }
+        if (this.playAutomatically)
+            this.init();
+    }
+
+    onEnable(): void {
+        if (this.playAutomatically && this.actions.length > 0 && this.currentActions.length <= 0) {
+            const index = Math.floor(Math.random() * this.actions.length);
+            this.play(index);
+        }
+    }
+
+    start() {
+        if (this.randomStartTime && this.currentAction)
+            this.currentAction.time = Math.random() * this.currentAction.getClip().duration;
+    }
+
+    update() {
+        if (!this.mixer) return;
+        this.mixer.update(this.context.time.deltaTime);
+        for (const handle of this._handles) {
+            handle._update();
+        }
+        if (this._handles?.length > 0)
+            InstancingUtil.markDirty(this.gameObject);
+    }
+
+    getAction(name: string): THREE.AnimationAction | undefined | null {
+        return this.actions?.find(a => a.getClip().name === name);
+    }
+
+    play(clipOrNumber: AnimationClip | number | string, options?: PlayOptions): Promise<AnimationAction> | void {
+        this.init();
+        if (!this.mixer) return;
+        let clip: AnimationClip | undefined = clipOrNumber as AnimationClip;
+        if (typeof clipOrNumber === 'number') {
+            if (clipOrNumber >= this.animations.length) return;
+            clip = this.animations[clipOrNumber];
+        }
+        else if (typeof clipOrNumber === "string") {
+            clip = this.animations.find(a => a.name === clipOrNumber);
+        }
+        if (!clip) {
+            console.error("Could not find clip", clipOrNumber)
+            return;
+        }
+        for (const act of this.actions) {
+            if (act.getClip() === clip) {
+                return this.internalOnPlay(act, options);
+            }
+        }
+        const act = this.mixer.clipAction(clip);
+        this.actions.push(act);
+        return this.internalOnPlay(act, options);
+    }
+
+    internalOnPlay(action: AnimationAction, options?: PlayOptions): Promise<AnimationAction> {
+        var prev = this.currentAction;
+        if (prev === action && prev.isRunning() && prev.time < prev.getClip().duration) {
+            const handle = this.tryFindHandle(action);
+            if (handle) return handle.getPromise();
+        }
+        const stopOther = options?.exclusive ?? true;
+        if (options?.fadeDuration) {
+            if (stopOther)
+                prev?.fadeOut(options.fadeDuration);
+            action.fadeIn(options.fadeDuration);
+        }
+        else {
+            if (stopOther)
+                prev?.stop();
+        }
+        action.reset();
+        action.enabled = true;
+        action.time = 0;
+        action.timeScale = 1;
+        if (options?.clampWhenFinished) action.clampWhenFinished = true;
+        if (options?.startTime !== undefined) action.time = options.startTime;
+
+        if (options?.loop !== undefined)
+            action.loop = options.loop ? THREE.LoopRepeat : THREE.LoopOnce;
+        action.play();
+        // console.log("PLAY", action.getClip().name, action)
+
+        const handle = new AnimationHandle(action, this.mixer!, options, _ => {
+            this._handles.splice(this._handles.indexOf(handle), 1);
+            // console.log(this._handles);
+        });
+        this._handles.push(handle);
+        return handle.getPromise();
+    }
+
+    private tryFindHandle(action: AnimationAction): AnimationHandle | undefined {
+        for (const handle of this._handles) {
+            if (handle.action === action)
+                return handle;
+        }
+        return undefined;
+    }
+
+
+    private _didInit = false;
+    init() {
+        if (this._didInit) return;
+        this._didInit = true;
+        if (!this.gameObject) return;
+        this.actions = [];
+        this.mixer = new THREE.AnimationMixer(this.gameObject);
+
+        for (let i = 0; i < this.animations.length; i++) {
+            const action = this.mixer.clipAction(this.animations[i]);
+            this.actions.push(action);
+        }
+    }
+}
+
+
+class AnimationHandle {
+    mixer: THREE.AnimationMixer;
+    action: THREE.AnimationAction;
+    promise: Promise<AnimationAction> | null = null;
+    resolve: Function | null = null;
+    reject: Function | null = null;
+
+    private _options?: PlayOptions | undefined;
+    private _resolveCallback: Function | null = null;
+    private _rejectCallback: Function | null = null;
+    private _loopCallback?: any;
+    private _finishedCallback?: any;
+    private _resolvedOrRejectedCallback?: (AnimationHandle) => void;
+
+    constructor(action: THREE.AnimationAction, mixer: THREE.AnimationMixer, opts?: PlayOptions, cb?: (handle: AnimationHandle) => void) {
+        this.action = action;
+        this.mixer = mixer;
+        this._resolvedOrRejectedCallback = cb;
+        this._options = opts;
+    }
+
+    getPromise(): Promise<AnimationAction> {
+        if (this.promise) return this.promise;
+
+        this.promise = new Promise((res, rej) => {
+            this._resolveCallback = res;
+            this._rejectCallback = rej;
+            this.resolve = this.onResolve.bind(this);
+            this.reject = this.onReject.bind(this);
+        });
+
+        this._loopCallback = this.onLoop.bind(this);
+        this._finishedCallback = this.onFinished.bind(this);
+        this.mixer.addEventListener('loop', this._loopCallback);
+        this.mixer.addEventListener('finished', this._finishedCallback);
+
+        return this.promise;
+    }
+
+    _update() {
+
+        if (!this._options) return;
+        if (this._options.endTime !== undefined && this.action.time > this._options.endTime) {
+            if (this._options.loop === true) {
+                this.action.time = this._options.startTime ?? 0;
+            }
+            else {
+                // this.action.stop();
+                this.action.time = this._options.endTime;
+                this.action.timeScale = 0;
+                // if (!this._options.clampWhenFinished)
+                //     this.action.stop();
+                this.onResolve();
+            }
+        }
+    }
+
+    private onResolve() {
+        this.dispose();
+        this._resolvedOrRejectedCallback?.call(this, this);
+        this._resolveCallback?.call(this, this.action);
+    }
+
+    private onReject(reason: any) {
+        this.dispose();
+        this._resolvedOrRejectedCallback?.call(this, this);
+        this._rejectCallback?.call(this, reason);
+    }
+
+    private onLoop(_evt: MixerEvent) {
+        // console.log("LOOP");
+    }
+
+    private onFinished(evt: MixerEvent) {
+        if (evt.action === this.action) {
+            // console.log("FINISHED", evt, this.action);
+            this.onResolve();
+        }
+    }
+
+    private dispose() {
+        if (this._loopCallback)
+            this.mixer.removeEventListener('loop', this._loopCallback);
+        if (this._finishedCallback)
+            this.mixer.removeEventListener('finished', this._finishedCallback);
+        this._loopCallback = undefined;
+        this._finishedCallback = undefined;
+    }
+}

package/src/engine-components/AnimationCurve.ts

@@ -0,0 +1,42 @@
+import { Mathf } from "../engine/engine_math";
+import { serializeable } from "../engine/engine_serialization_decorator";
+
+class Keyframe {
+    @serializeable()
+    time!: number;
+    @serializeable()
+    value!: number;
+    @serializeable()
+    inTangent!: number;
+    @serializeable()
+    inWeight!: number;
+    @serializeable()
+    outTangent!: number;
+    @serializeable()
+    outWeight!: number;
+    @serializeable()
+    weightedMode!: number;
+}
+
+export class AnimationCurve {
+
+    @serializeable(Keyframe)
+    keys!: Array<Keyframe>;
+    
+    get duration() : number {
+        if(!this.keys || this.keys.length == 0) return 0;
+        return this.keys[this.keys.length - 1].time;
+    } 
+
+    evaluate(time: number): number {
+        if(!this.keys || this.keys.length == 0) return 0;
+        let lastKeyframe : Keyframe | null = null;
+        for (const kf of this.keys) {
+            if (lastKeyframe && kf.time > time && time > lastKeyframe!.time) {
+                return Mathf.lerp(lastKeyframe!.value, kf.value, (time - lastKeyframe!.time) / (kf.time - lastKeyframe!.time));
+            }
+            lastKeyframe = kf;
+        }
+        return this.keys[this.keys.length-1].value;
+    }
+}