@needle-tools/engine 2.24.0-pre

package/src/engine/engine.ts

@@ -0,0 +1,15 @@
+import * as engine_setup from "./engine_setup";
+import * as engine_scenetools from "./engine_scenetools";
+import "./tests/test_utils";
+import { RGBAColor } from "../engine-components/js-extensions/RGBAColor";
+import { makeErrorsVisibleForDevelopment } from "./debug/error_overlay";
+
+makeErrorsVisibleForDevelopment();
+
+const engine = {
+    ...engine_setup,
+    ...engine_scenetools,
+    RGBAColor,
+};
+
+export { engine as engine }

package/src/engine/engine_addressables.ts

@@ -0,0 +1,297 @@
+import { getParam, getPath } from "../engine/engine_utils";
+import { GameObject, InstantiateOptions } from "../engine-components/Component";
+import { loadSync, parseSync } from "./engine_scenetools";
+import { SerializationContext, TypeSerializer } from "./engine_serialization_core";
+import { Context } from "./engine_setup";
+import { Group, LogLuvEncoding, Object3D, Scene } from "three";
+import { processNewScripts } from "./engine_mainloop_utils";
+import { InstantiateEvent, registerPrefabProvider, syncInstantiate } from "./engine_networking_instantiate";
+import { download } from "./engine_web_api";
+import { SourceIdentifier } from "./engine_gltf";
+
+const debug = getParam("debugaddressables");
+
+export class Addressables {
+
+    private _context: Context;
+
+    constructor(context: Context) {
+        this._context = context;
+        this._context.pre_update_callbacks.push(this.preUpdate.bind(this));
+    }
+
+    private preUpdate() {
+
+    }
+
+    private _assetReferences: { [key: string]: AssetReference } = {};
+
+    findAssetReference(uri: string): AssetReference | null {
+        return this._assetReferences[uri] || null;
+    }
+
+    registerAssetReference(ref: AssetReference): AssetReference {
+        if (!ref.uri) return ref;
+        if (!this._assetReferences[ref.uri]) {
+            this._assetReferences[ref.uri] = ref;
+        }
+        else {
+
+            console.warn("Asset reference already registered", ref);
+        }
+        return ref;
+    }
+}
+
+export type ProgressCallback = (asset: AssetReference, prog: ProgressEvent) => void;
+
+export class AssetReference {
+
+    static getOrCreate(sourceId: SourceIdentifier, uri: string, context: Context): AssetReference {
+        const fullPath = getPath(sourceId, uri);
+        if(debug) console.log("GetOrCreate Addressable from", sourceId, uri, "FinalPath=", fullPath);
+        const addressables = context.addressables;
+        const existing = addressables.findAssetReference(fullPath);
+        if (existing) return existing;
+        const ref = new AssetReference(fullPath);
+        addressables.registerAssetReference(ref);
+        return ref;
+    }
+
+    get asset(): any {
+        return this._glbRoot ?? this._asset;
+    }
+    protected set asset(val: any) {
+        this._asset = val;
+    }
+
+    private _loading?: PromiseLike<any>;
+
+    get uri(): string {
+        return this._uri!;
+    }
+
+    get rawAsset(): any { return this._asset; }
+
+    private _asset: any;
+    private _glbRoot?: Object3D | null;
+    private _uri: string;
+    private _progressListeners: ProgressCallback[] = [];
+
+    private _isLoadingRawBinary: boolean = false;
+    private _rawBinary?: ArrayBuffer | null;
+
+    constructor(uri: string) {
+        this._uri = uri;
+        registerPrefabProvider(this._uri, this.onResolvePrefab.bind(this));
+    }
+
+    private async onResolvePrefab(uri: string): Promise<GameObject | null> {
+        if (uri === this.uri) {
+            if (this.mustLoad) await this.loadAssetAsync();
+            if (this.asset) {
+                return this.asset;
+            }
+        }
+        return null;
+    }
+
+    private get mustLoad() {
+        return !this.asset || this.asset.__destroyed === true;
+    }
+
+    isLoaded() { return this._rawBinary || this.asset !== undefined }
+
+    unload() {
+        if (this.asset) {
+            if (debug) console.log("Unload", this.asset);
+            // TODO: we need a way to remove objects from the context (including components) without actually "destroying" them
+            if (this.asset.scene)
+                GameObject.destroy(this.asset.scene);
+            else GameObject.destroy(this.asset);
+        }
+        this.asset = null;
+    }
+
+    async preload(): Promise<ArrayBuffer | null> {
+        if (!this.mustLoad) return null;
+        if (this._isLoadingRawBinary) return null;
+        if (this._rawBinary !== undefined) return this._rawBinary;
+        this._isLoadingRawBinary = true;
+        if (debug) console.log("Preload", this.uri);
+        const res = await download(this.uri, p => {
+            this.raiseProgressEvent(p);
+        });
+        this._rawBinary = res?.buffer ?? null;
+        this._isLoadingRawBinary = false;
+        return this._rawBinary;
+    }
+
+    async loadAssetAsync(prog?: ProgressCallback | null) {
+        if (!this.mustLoad) return;
+        if (prog)
+            this._progressListeners.push(prog);
+        if (this._loading !== undefined) {
+            // console.warn("Wait for other loading thiny");
+            return this._loading;
+        }
+        const context = Context.Current;
+        // TODO: technically we shouldnt call awake only when the object is added to a scene
+        // addressables now allow loading things without adding them to a scene immediately
+        // we should "address" (LUL) this
+        // console.log("START LOADING");
+        if (this._rawBinary) {
+            this._loading = parseSync(context, this._rawBinary, this.uri, null);
+            this.raiseProgressEvent(new ProgressEvent("progress", { loaded: this._rawBinary.byteLength, total: this._rawBinary.byteLength }));
+        }
+        else {
+            if (debug) console.log("Load async", this.uri);
+            this._loading = loadSync(context, this.uri, null, true, prog => {
+                this.raiseProgressEvent(prog);
+            });
+        }
+        const res = await this._loading;
+        // clear all progress listeners after download has finished
+        this._progressListeners.length = 0;
+        this._glbRoot = this.tryGetActualGameObjectRoot(res);
+        this._loading = undefined;
+        if (res) {
+            // we need to handle the pre_setup callsbacks before instantiating
+            // because that is where deserialization happens
+            processNewScripts(context);
+
+            if (res.scene !== undefined) {
+                this.asset = res;
+            }
+            return this.asset;
+        }
+    }
+
+    async instantiate(parent?: THREE.Object3D | InstantiateOptions) {
+        return this.onInstantiate(parent, false);
+    }
+
+    async instantiateSynced(parent?: THREE.Object3D | InstantiateOptions, saveOnServer: boolean = true) {
+        return this.onInstantiate(parent, true, saveOnServer);
+    }
+
+    beginListenDownload(evt: ProgressCallback) {
+        if (this._progressListeners.indexOf(evt) < 0)
+            this._progressListeners.push(evt);
+    }
+
+    endListenDownload(evt: ProgressCallback) {
+        const index = this._progressListeners.indexOf(evt);
+        if (index >= 0) {
+            this._progressListeners.splice(index, 1);
+        }
+    }
+
+    private raiseProgressEvent(prog: ProgressEvent) {
+        for (const list of this._progressListeners) {
+            list(this, prog);
+        }
+    }
+
+    private async onInstantiate(parent?: THREE.Object3D | InstantiateOptions, networked: boolean = false, saveOnServer?: boolean) {
+        const context = Context.Current;
+        if (!parent) parent = context.scene;
+        if (this.mustLoad) {
+            await this.loadAssetAsync();
+        }
+        if (debug)
+            console.log("Instantiate", this.uri, "parent:", parent);
+
+        if (this.asset) {
+            if (debug) console.log("Add to scene", this.asset);
+
+            let options = parent instanceof InstantiateOptions ? parent : null;
+            if (!options) {
+                options = new InstantiateOptions();
+            }
+
+            if (typeof parent === "object") {
+                if (parent instanceof Object3D) {
+                    options.parent = parent;
+                }
+                else {
+                    Object.assign(options, parent);
+                }
+            }
+
+            if (networked) {
+                options.context = context;
+                const prefab = this.asset;
+                prefab.guid = this.uri;
+                const instance = syncInstantiate(prefab, options, undefined, saveOnServer);
+                if (instance) {
+                    return instance;
+                }
+            }
+            else {
+                const instance = GameObject.instantiate(this.asset, options);
+                if (instance) {
+                    return instance;
+                }
+            }
+        }
+        else if (debug) console.warn("Failed to load asset", this.uri);
+        return null;
+    }
+
+    /**
+     * try to ignore the intermediate created object
+     * because it causes trouble if we instantiate an assetreference per player
+     * and call destroy on the player marker root
+     * @returns the scene root object if the asset was a glb/gltf
+     */
+    private tryGetActualGameObjectRoot(asset: any): THREE.Object3D | null {
+        if (asset && asset.scene) {
+            // some exporters produce additional root objects
+            const scene = asset.scene as Group;
+            if (scene.isGroup && scene.children.length === 1 && scene.children[0].name + "glb" === scene.name) {
+                const root = scene.children[0];
+                return root;
+            }
+            // ok the scene is the scene, just use that then
+            else
+                return scene;
+        }
+        return null;
+    }
+
+}
+
+
+
+
+class AddressableSerializer extends TypeSerializer {
+
+    constructor() {
+        super([AssetReference]);
+    }
+
+    onSerialize(data: any, _context: SerializationContext) {
+        if (data && data.uri !== undefined && typeof data.uri === "string") {
+            return data.uri;
+        }
+    }
+
+    onDeserialize(data: any, context: SerializationContext) {
+        if (typeof data === "string") {
+            if (!context.context) {
+                console.error("Missing context");
+                return null;
+            }
+            if (!context.gltfId) {
+                console.error("Missing spurce id");
+                return null;
+            }
+            const ref = AssetReference.getOrCreate(context.gltfId, data, context.context);
+            return ref;
+        }
+        return null;
+    }
+
+}
+new AddressableSerializer();

package/src/engine/engine_application.ts

@@ -0,0 +1,42 @@
+import { Context } from "./engine_setup";
+
+export enum ApplicationEvents {
+    Visible = "application-visible",
+    Hidden = "application-hidden",
+}
+
+export class Application extends EventTarget {
+
+    private context : Context;
+
+    public get hasFocus() : boolean {
+        return document.hasFocus();
+    }
+
+    public get isVisible(): boolean {
+        return this._isVisible;
+    }
+
+    private _isVisible: boolean = true;
+
+    constructor(context : Context) {
+        super();
+        this.context = context;
+        // console.log("APP");
+        window.addEventListener("visibilitychange", this.onVisiblityChanged.bind(this), false);
+    }
+
+    private onVisiblityChanged(evt) {
+        // console.log(evt.target.visibilityState)
+        switch (evt.target.visibilityState) {
+            case "hidden":
+                this._isVisible = false;
+                this.dispatchEvent(new Event(ApplicationEvents.Hidden));
+                break;
+            case "visible":
+                this._isVisible = true;
+                this.dispatchEvent(new Event(ApplicationEvents.Visible));
+                break;
+        }
+    }
+}

package/src/engine/engine_assetdatabase.ts

@@ -0,0 +1,215 @@
+import * as THREE from 'three';
+import { Scene } from 'three';
+// import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js'
+import * as utils from "./engine_utils";
+
+const debug = utils.getParam("debugassets");
+
+class TextureInfo {
+    name!: string;
+    sampler!: number;
+    source!: number;
+    extras: { guid: string } | undefined;
+}
+
+class ImageInfo {
+    bufferView!: number;
+    mimeType: string | undefined;
+    extras: { guid: string } | undefined;
+}
+
+class GltfJson {
+    textures!: TextureInfo[];
+    bufferViews!: Array<{ buffer: number, byteOffset: number, byteLength: number }>;
+}
+
+declare class GltfParser {
+    cache: any;
+    json: GltfJson;
+    associations: Map<any, any>;
+    textureLoader: THREE.TextureLoader;
+    loadTexture: Function;
+}
+
+declare class Gltf {
+    parser: GltfParser;
+    scene: Scene;
+}
+
+/** @deprecated */
+export class AssetDatabase {
+
+    constructor() {
+        window.addEventListener('unhandledrejection', (event: PromiseRejectionEvent) => {
+            if (event.defaultPrevented) return;
+            const pathArray = event?.reason?.path;
+            if (pathArray) {
+                const source = pathArray[0];
+                if (source && source.tagName === "IMG") {
+                    console.warn("Could not load image:\n" + source.src);
+                    event.preventDefault();
+                }
+            }
+        });
+    }
+
+    private texturesLoader: THREE.TextureLoader = new THREE.TextureLoader();
+    private textures: { [key: string]: THREE.Texture | PromiseLike<THREE.Texture> } = {};
+    private texturesLoading: { [key: string]: THREE.Texture | PromiseLike<THREE.Texture> } = {};
+
+    /** @deprecated */
+    public async loadTexture(url: string): Promise<THREE.Texture | null> {
+        if (this.textures[url]) {
+            return this.textures[url];
+        }
+        if (this.texturesLoading[url]) {
+            return await this.texturesLoading[url];
+        }
+        const loading = this.texturesLoader.loadAsync(url);
+        this.texturesLoading[url] = loading;
+        const res = await loading;
+        delete this.texturesLoading[url];
+        this.textures[url] = res;
+        return res;
+    }
+
+    /** @deprecated */
+    public getTexture(guid: string): THREE.Texture | null {
+        return this._textures.get(guid) || null;
+    }
+
+    /** @deprecated */
+    public findTexture(name: string): THREE.Texture | null {
+        for (const texture of this._textures.values()) {
+            if (texture.name === name) {
+                return texture;
+            }
+        }
+        return null;
+    }
+
+    /** @deprecated */
+    public findMesh(name: string): THREE.Mesh | null {
+        for (const mesh of this._meshes.values()) {
+            if (mesh.name === name)
+                return mesh;
+        }
+        return null;
+    }
+
+    /** @deprecated */
+    public findMaterial(name:string) : THREE.Material | null {
+        for (const material of this._materials.values()) {
+            if (material.name === name)
+                return material;
+        }
+        return null;
+    }
+
+    /** @deprecated */
+    public async registerGltf(_gltf: Gltf) {
+        // if (debug)
+        //     console.log("register gltf", gltf.scene.name, gltf);
+        // const parser = gltf.parser;
+        // const json = parser.json;
+        // const textures = json.textures;
+        // const associations = parser.associations;
+        // const alreadyLoaded = new Set<string>();
+        // associations.forEach((value, key) => {
+        //     // when minified instanceOf doesnt work but the texture type is 1009
+        //     if (key instanceof THREE.Texture || key.type === 1009) {
+        //         const index = value.textures;
+        //         const textureInfo = textures[index];
+        //         // TODO: a lot of information is gone when compressing with ktx2
+        //         // this.registerTexture(parser, index, textureInfo, key, alreadyLoaded);
+        //     }
+        //     else if (key instanceof THREE.Mesh || key.type == "Mesh") {
+        //         this.registerAsset(key);
+
+        //         // saving materials,
+        //         // FIXME: this is unlike the other things by name here as a hack for forma, it should probably saved by name and by guid just like anything else here
+        //         if(key.material){
+        //             this._materials.set(key.material.name, key.material);
+        //         }
+        //     }
+        // });
+
+        // // for (const ti in textures) {
+        // //     const textureInfo = textures[ti];
+        // //     await this.registerTexture(parser, ti, textureInfo, null, alreadyLoaded);
+        // // }
+
+        // if (debug)
+        //     console.log(this);
+    }
+
+    /** @deprecated */
+    public registerAsset(_asset: any) {
+        // if (debug) console.log("register asset", asset);
+        // console.assert(asset, "Asset is null or undefined");
+        // const guid: string = asset.userData?.guid;
+        // if (guid === null || guid === undefined || guid.length === 0) {
+        //     // asset has no guid, this can happen e.g. when using multi material meshes
+        //     // should we ask the parent for the guid if it's a group? 
+        //     // we need a more stable way to preserve ids anyways
+        //     return;
+        // }
+        // if (asset instanceof THREE.Texture || asset.type === 1009) {
+        //     if (this._textures.has(guid) && this._textures.get(guid) !== asset) {
+        //         if (debug)
+        //             console.warn("found duplicate texture " + guid, asset);
+        //         return;
+        //     }
+        //     if (debug)
+        //         console.log("register texture", guid, asset);
+        //     // should we check if an asset has been registered already? 
+        //     // should not matter as long as we only export guid from unity?
+        //     this._textures.set(guid, asset);
+        // }
+        // else if (asset instanceof THREE.Mesh || asset.type == "Mesh") {
+        //     this._meshes.set(guid, asset);
+        // }
+    }
+
+
+    private _materials: Map<string, THREE.Material> = new Map<string, THREE.Material>();
+    private _meshes: Map<string, THREE.Mesh> = new Map();
+    // private async registerMesh(parser: GltfParser, mesh : THREE.Mesh){        
+    //     const guid = mesh?.userData?.guid;
+    // }
+
+
+    private _textures: Map<string, THREE.Texture> = new Map();
+
+    // private async registerTexture(parser: GltfParser, index: number | string, textureInfo: TextureInfo, texture: THREE.Texture | null, alreadyLoaded: Set<string>) {
+
+    //     // const guid = textureInfo?.extras?.guid || texture?.userData?.guid;
+    //     // if (!guid) {
+    //     //     if (debug) console.warn("missing guid", texture, textureInfo)
+    //     //     return;
+    //     // }
+    //     // console.assert(guid !== null && guid !== undefined && guid.length > 0, "Texture has no guid in userData", texture);
+    //     // if (guid) {
+    //     //     if (alreadyLoaded.has(guid)) {
+    //     //         // console.warn("texture already loaded", textureInfo.name, guid);
+    //     //         return;
+    //     //     }
+    //     //     alreadyLoaded.add(guid);
+    //     // }
+
+    //     // if (!texture) {
+    //     //     texture = await parser.loadTexture(index);
+    //     //     if (!texture) {
+    //     //         if (debug)
+    //     //             console.warn("failed to load texture", guid);
+    //     //         return;
+    //     //     }
+    //     // }
+
+    //     // if (textureInfo.extras) {
+    //     //     texture.userData = { ...texture.userData, ...textureInfo.extras };
+    //     // }
+    //     // this.registerAsset(texture);
+    // }
+
+}