@needle-tools/engine 2.24.0-pre

package/src/engine/engine_utils.ts

@@ -0,0 +1,268 @@
+
+
+// use for typesafe interface method calls
+import { SourceIdentifier } from "./engine_gltf";
+
+// https://schneidenbach.gitbooks.io/typescript-cookbook/content/nameof-operator.html
+export const nameofFactory = <T>() => (name: keyof T) => name;
+export function nameof<T>(name: keyof T) {
+    return nameofFactory<T>()(name);
+}
+
+
+export function isDebugMode(): boolean {
+    return getParam("debug") ? true : false;
+}
+
+
+
+let saveParams: boolean = false;
+const requestedParams: Array<string> = [];
+setTimeout(() => {
+    if (saveParams)
+        console.log(requestedParams);
+}, 100);
+
+export function getUrlParams() {
+    return new URLSearchParams(window.location.search);
+}
+
+export function getParam(paramName: string): string | boolean {
+
+    if (saveParams && !requestedParams.includes(paramName))
+        requestedParams.push(paramName);
+    const urlParams = getUrlParams();
+    if (urlParams.has(paramName)) {
+        const val = urlParams.get(paramName);
+        if (val) {
+            return val;
+        }
+        else return true;
+    }
+    return false;
+}
+saveParams = getParam("help") === true;
+
+export function setParam(paramName: string, paramValue: string): void {
+    const urlParams = getUrlParams();
+    if (urlParams.has(paramName)) {
+        urlParams.set(paramName, paramValue);
+    }
+    else
+        urlParams.append(paramName, paramValue);
+    document.location.search = urlParams.toString();
+}
+
+export function setParamWithoutReload(paramName: string, paramValue: string, appendHistory = true): void {
+    const urlParams = getUrlParams();
+    if (urlParams.has(paramName)) {
+        urlParams.set(paramName, paramValue);
+    }
+    else
+        urlParams.append(paramName, paramValue);
+    if (appendHistory) pushState(paramName, urlParams);
+    else setState(paramName, urlParams);
+}
+
+export function setOrAddParamsToUrl(url: URLSearchParams, paramName: string, paramValue: string | number): void {
+    if (url.has(paramName)) {
+        url.set(paramName, paramValue.toString());
+    }
+    else
+        url.append(paramName, paramValue.toString());
+}
+
+export function pushState(title: string, urlParams: URLSearchParams) {
+    window.history.pushState(null, title, "?" + urlParams.toString());
+}
+
+export function setState(title: string, urlParams: URLSearchParams) {
+    window.history.replaceState(null, title, "?" + urlParams.toString());
+}
+
+// for room id
+export function makeId(length): string {
+    var result = '';
+    var characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    var charactersLength = characters.length;
+    for (var i = 0; i < length; i++) {
+        result += characters.charAt(Math.floor(Math.random() *
+            charactersLength));
+    }
+    return result;
+}
+
+export function randomNumber(min, max) {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+const adjectives = ["smol", "tiny", "giant", "interesting", "smart", "bright", "dull", "extreme", "beautiful", "pretty", "dark", "epic", "salty", "silly", "funny", "lame", "lazy", "loud", "lucky", "mad", "mean", "mighty", "mysterious", "nasty", "odd", "old", "powerful", "quiet", "rapid", "scary", "shiny", "shy", "silly", "smooth", "sour", "spicy", "stupid", "sweet", "tasty", "terrible", "ugly", "unusual", "vast", "wet", "wild", "witty", "wrong", "zany", "zealous", "zippy", "zombie", "zorro"];
+const nouns = ["cat", "dog", "mouse", "pig", "cow", "horse", "sheep", "chicken", "duck", "goat", "panda", "tiger", "lion", "elephant", "monkey", "bird", "fish", "snake", "frog", "turtle", "hamster", "penguin", "kangaroo", "whale", "dolphin", "crocodile", "snail", "ant", "bee", "beetle", "butterfly", "dragon", "eagle", "fish", "giraffe", "lizard", "panda", "penguin", "rabbit", "snake", "spider", "tiger", "zebra"]
+export function makeIdFromRandomWords(): string {
+    const randomAdjective = adjectives[Math.floor(Math.random() * adjectives.length)];
+    const randomNoun = nouns[Math.floor(Math.random() * nouns.length)];
+    return randomAdjective + "_" + randomNoun;
+}
+
+// for url parameters
+export function sanitizeString(str): string {
+    str = str.replace(/[^a-z0-9áéíóúñü \.,_-]/gim, "");
+    return str.trim();
+}
+
+
+// TODO: taken from scene utils
+export function tryFindObject(globalObjectIdentifier: string, obj, recursive: boolean = true, searchComponents: boolean = false) {
+    if (obj === undefined || obj === null) return null;
+
+    if (obj.userData && obj.userData.guid === globalObjectIdentifier) return obj;
+    else if (obj.guid == globalObjectIdentifier) return obj;
+
+    if (searchComponents) {
+        if (obj.userData?.components) {
+            for (const comp of obj.userData.components) {
+                if (comp.guid === globalObjectIdentifier) return comp;
+            }
+        }
+    }
+
+    if (recursive) {
+
+        if (obj.scenes) {
+            for (const i in obj.scenes) {
+                const scene = obj.scenes[i];
+                const found = tryFindObject(globalObjectIdentifier, scene, recursive, searchComponents);
+                if (found) return found;
+            }
+        }
+
+        if (obj.children) {
+            for (const i in obj.children) {
+                const child = obj.children[i];
+                const found = tryFindObject(globalObjectIdentifier, child, recursive, searchComponents);
+                if (found) return found;
+            }
+        }
+    }
+}
+
+declare type deepClonePredicate = (owner: any, propertyName: string, current: any) => boolean;
+
+export function deepClone(obj: any, predicate?: deepClonePredicate): any {
+    if (obj !== null && obj !== undefined && typeof obj === "object") {
+        let clone;
+        if (Array.isArray(obj)) clone = [];
+        else {
+            clone = Object.create(obj);
+            Object.assign(clone, obj);
+        }
+        for (const key of Object.keys(obj)) {
+            const val = obj[key];
+            if (predicate && !predicate(obj, key, val)) {
+                // console.log("SKIP", val);
+                clone[key] = val;
+            }
+            else if (val?.clone !== undefined && typeof val.clone === "function")
+                clone[key] = val.clone();
+            else
+                clone[key] = deepClone(val, predicate);
+        }
+        return clone;
+    }
+    return obj;
+}
+
+export function delay(milliseconds: number): Promise<void> {
+    return new Promise((res, _) => {
+        setTimeout(res, milliseconds);
+    });
+}
+
+// if a timeline is exported via menu item the audio clip path is relative to the glb (same folder)
+// we need to detect that here and build the new audio source path relative to the new glb location
+// the same is/might be true for any file that is/will be exported via menu item
+export function getPath(glbLocation: SourceIdentifier | undefined, path: string) {
+    if (path && glbLocation && !path.includes("/")) {
+        // get directory of glb and prepend it to the audio file path
+        const pathIndex = glbLocation.lastIndexOf("/");
+        if (pathIndex >= 0) {
+            const newPath = glbLocation.substring(0, pathIndex + 1) + path;
+            return newPath;
+        }
+    }
+    return path;
+}
+
+export type WriteCallback = (data: any) => void;
+
+// TODO: make it possible to add multiple watches to the same object property
+export class Watch {
+
+    subscribeWrite(callback: WriteCallback) {
+        this.writeCallbacks.push(callback);
+    }
+    private writeCallbacks: (WriteCallback)[] = [];
+
+    constructor(object: object, prop: string) {
+        this._object = object;
+        this._prop = prop;
+        this._wrapperProp = "__$_NEEDLE_" + prop;
+        this.apply();
+    }
+
+    private _applied: boolean = false;
+    private _object: any;
+    private _prop: string;
+    private _wrapperProp: string;
+
+    apply() {
+        if (this._applied) return;
+        if (!this._object) return;
+        const object = this._object;
+        const prop = this._prop;
+        if (object[prop] === undefined) return;
+        this._applied = true;
+
+        if(object[this._wrapperProp] !== undefined){
+            console.warn("Watcher is being applied to an object that already has a wrapper property. This is not (yet) supported");
+        }
+
+        // create a wrapper property
+        const current = object[prop];
+        object[this._wrapperProp] = current;
+        // create wrapper methods
+        const getter = () => {
+            // console.log("GET " + prop);
+            return object[this._wrapperProp];
+        }
+        const setter = (value) => {
+            object[this._wrapperProp] = value;
+            for (const write of this.writeCallbacks) {
+                write(value);
+            }
+        }
+        // add the wrapper to the object
+        Object.defineProperty(object, prop, {
+            get: getter,
+            set: setter
+        });
+    }
+
+    revoke() {
+        if (!this._applied) return;
+        if (!this._object) return;
+        this._applied = false;
+        const object = this._object;
+        const prop = this._prop;
+        Reflect.deleteProperty(object, prop);
+        const current = object[this._wrapperProp];
+        object[prop] = current;
+        Reflect.deleteProperty(object, this._wrapperProp);
+    }
+
+    dispose() {
+        this.revoke();
+        this.writeCallbacks.length = 0;
+        this._object = null;
+    }
+}

package/src/engine/engine_web_api.ts

@@ -0,0 +1,122 @@
+// workaround for this is not a function when deployed
+// see https://github.com/pvorb/node-md5/issues/52
+import md5 from "md5";
+
+// const backend_url = null;// "https://needle-storage-castle-demo.glitch.me";
+
+export class Upload_Result {
+    success: boolean;
+    filename: string | null;
+    hash: string | null;
+    size: number | null;
+    url?: string | null;
+
+    constructor(success: boolean, filename: string | null, hash: string | null, size: number | null) {
+        this.success = success;
+        this.filename = filename;
+        this.hash = hash;
+        this.size = size;
+    }
+}
+
+export async function upload_file(file: File, url: string): Promise<Upload_Result | null> {
+    const buffer = await file.arrayBuffer();
+    const hashString = hash(buffer);
+    const ext = file.name.split('.').pop();
+    const filename = hashString + "." + ext;
+    const alias = file.name.split('.').shift();
+    console.assert(alias !== undefined);
+    const body = { alias: alias, filename: filename };
+    const exists = await fetch(url + '/exists', { method: "POST", body: JSON.stringify(body) });
+    const answer: { success: boolean, exists: boolean } = await exists.json();
+    if (!answer.success) {
+        console.warn("exists check did fail");
+    }
+    if (answer.exists) {
+        console.log("file already exists", hashString);
+        return new Upload_Result(true, filename, hashString, file.size);
+    }
+
+    console.log("begin uploading file", alias, file.size);
+    const formData = new FormData();
+    formData.append("file", file);
+    const headers: Record<string, string> = {};
+    headers["filesize"] = file.size as unknown as string;
+    if (alias)
+        headers["alias"] = alias;
+    const upload_res_raw = await fetch(url + '/upload/file', { method: "POST", body: formData, headers: headers });
+    const upload_res: { success: boolean, id: string, hash_sum: string, message?: string } = await upload_res_raw.json();
+    if (upload_res?.success === false) {
+        if (upload_res.message !== undefined) {
+            console.error("Upload failed:", upload_res.message);
+        }
+        else {
+            console.error("Upload failed");
+        }
+        return null;
+    }
+    console.assert(upload_res.hash_sum === hashString, "hash sum did not match", "received:", upload_res.hash_sum, "expected:", hashString);
+    if (upload_res.success) console.log("successfully uploaded", hashString, upload_res.id);
+    const res = new Upload_Result(upload_res.success, filename, hashString, file.size);
+    res.url = url;
+    return res;
+}
+
+export function hash(buffer: ArrayBuffer): string {
+    return md5(new Uint8Array(buffer))
+};
+
+export async function download_file(filename: string, expectedHash: string, expectedSize: number, serverUrl: string, skipChecks: boolean = false): Promise<ArrayBuffer | null> {
+    try {
+        const download_res = await fetch(serverUrl + '/download/file', { method: "POST", body: filename });
+        if (download_res.status !== 200) {
+            // const res = await download_res.json();
+            console.error("download failed", download_res);
+            return null;
+        }
+        const bin = await download_res.blob();
+        const buffer = await bin.arrayBuffer();
+        if (!skipChecks)
+            console.assert(bin.size === expectedSize, "size mismatch", "expected:", expectedSize, "got:", bin.size);
+        const result_hash = hash(buffer);
+        if (!skipChecks)
+            console.assert(result_hash === expectedHash, "hash mismatch, downloaded file is invalid");
+        return bin.arrayBuffer();
+    }
+    catch (err) {
+        console.error(err);
+    }
+    return null;
+}
+
+export async function download(url: string, progressCallback: (prog: ProgressEvent) => void) : Promise<Uint8Array | null> {
+    const response = await fetch(url);
+
+    const reader = response.body?.getReader();
+    const contentLength = response.headers.get('Content-Length');
+    const total = contentLength ? parseInt(contentLength) : 0;
+
+    if (!reader) return null;
+
+    let received: number = 0;
+    let chunks: Uint8Array[] = [];
+    while (true) {
+        const { done, value } = await reader.read();
+        if (value) {
+            chunks.push(value);
+            received += value.length;
+            progressCallback.call(null, new ProgressEvent('progress', { loaded: received, total: total }));
+        }
+
+        if (done) {
+            break;
+        }
+    }
+    const final = new Uint8Array(received);
+    let position = 0;
+    for (let chunk of chunks) {
+        final.set(chunk, position);
+        position += chunk.length;
+    }
+    return final;
+}

package/src/engine/extensions/EXT_texture_exr.js

@@ -0,0 +1,42 @@
+import { getParam } from "../engine_utils";
+import { EXRLoader } from "three/examples/jsm/loaders/EXRLoader";
+
+const debug = getParam("debugexr");
+
+export class EXT_texture_exr {
+
+	constructor( parser ) {
+
+		this.parser = parser;
+		this.name = "EXT_texture_exr";
+
+	}
+
+	loadTexture( textureIndex ) {
+
+		const name = this.name;
+		const parser = this.parser;
+		const json = parser.json;
+
+		const textureDef = json.textures[ textureIndex ];
+
+		if(debug) console.log("EXT_texture_exr.loadTexture", textureIndex, textureDef);
+		
+		if ( ! textureDef.extensions || ! textureDef.extensions[ name ] ) {
+
+			return null;
+
+		}
+
+		const extension = textureDef.extensions[ name ];
+
+		// TODO should the loader be cached here?
+		let loader = new EXRLoader(parser.options.manager);
+
+		if(debug) console.log("EXT_texture_exr.loadTexture", extension, loader);
+
+		return parser.loadTextureImage( textureIndex, extension.source, loader );
+
+	}
+
+}