@needle-tools/engine 4.3.2-beta.2 → 4.3.2-beta.4

package/plugins/common/license.js

@@ -1,8 +1,7 @@
 import { spawn } from "child_process";
-import https from 'https';
-import http from 'http';
 
 const port = 8424;
+const packageName = "needle-cloud@version-1";
 const licenseServerUrl = `http://localhost:${port}/api/license`;
 const projectIdentifierUrl = `http://localhost:${port}/api/public_key`;
 
@@ -55,15 +54,33 @@ export async function resolveLicense(args = null) {
     console.log(`INFO: Fetching license...`);
     const licenseResponse = await fetch(url.toString(), {
         method: "GET",
-    }).catch(console.error);
+    }).catch(err => {
+        if (err.cause.code === "ECONNREFUSED") {
+            return { error: "ERR: Failed to connect to license server (ECONNREFUSED)" };
+        }
+        else {
+            return { error: "ERR: Failed to fetch license." };
+        }
+    });
+
     if (!licenseResponse) {
         console.warn("WARN: Failed to fetch license");
         return null;
     }
+    else if ("error" in licenseResponse) {
+        console.error(licenseResponse.error);
+        return null;
+    }
+    else if (!licenseResponse.ok) {
+        console.error("ERROR: Failed to fetch license");
+        return null;
+    }
+
+    const text = await licenseResponse.text();
 
     try {
         /** @type {{needle_engine_license:string}} */
-        const licenseJson = JSON.parse(licenseResponse);
+        const licenseJson = JSON.parse(text);
         console.log("\n");
         if (licenseJson.needle_engine_license) {
             console.log(`INFO: Successfully received \"${licenseJson.needle_engine_license?.toUpperCase()}\" license`)
@@ -99,14 +116,15 @@ export async function getPublicIdentifier(project_id) {
         method: "GET",
     });
 
-    if (!res) {
+    if (!res || !res.ok) {
         console.warn("WARN: Failed to fetch project identifier");
         return null;
     }
+    const text = await res.text();
 
     try {
         /** @type {{public_key:string}} */
-        const json = JSON.parse(res);
+        const json = JSON.parse(text);
         return json.public_key;
     }
     catch (err) {
@@ -121,7 +139,7 @@ export async function getPublicIdentifier(project_id) {
 // we need to to wait for the root URL to return a response
 async function waitForLicenseServer() {
     // Make sure the licensing server is running
-    runCommand("npx", ["--yes", "needle-cloud@main", "start-server"]);
+    runCommand("npx", ["--yes", packageName, "start-server"]);
 
     let attempts = 0;
     while (attempts < 10) {
@@ -152,7 +170,7 @@ async function runCommand(processName, args) {
             if (code === 0) {
                 resolve(true);
             } else {
-                console.warn(`WARN: ${processName} exited with code ${code}`);
+                console.warn(`WARN: \"${processName}\" process exited with code ${code}\nProcess Arguments: ${args.join(" ")}`);
                 resolve(false);
             }
         });
@@ -163,29 +181,21 @@ async function runCommand(processName, args) {
 }
 
 
-/**
- * @param {string} str
- */
-function obscure(str) {
-    const start = str.substring(0, 3);
-    return start + "******";
-}
-
 
 // NODE 16 doesn't support fetch yet
-function fetch(url, options) {
-    const module = url.startsWith("https") ? https : http;
-    return new Promise((resolve, reject) => {
-        module.get(url, options, (res) => {
-            let data = '';
-            res.on('data', (chunk) => {
-                data += chunk;
-            });
-            res.on('end', () => {
-                resolve(data);
-            });
-        }).on("error", (err) => {
-            reject(err);
-        });
-    });
-}
+// function fetch(url, options) {
+//     const module = url.startsWith("https") ? https : http;
+//     return new Promise((resolve, reject) => {
+//         module.get(url, options, (res) => {
+//             let data = '';
+//             res.on('data', (chunk) => {
+//                 data += chunk;
+//             });
+//             res.on('end', () => {
+//                 resolve(data);
+//             });
+//         }).on("error", (err) => {
+//             reject(err);
+//         });
+//     });
+// }

package/src/engine/engine_context.ts

@@ -10,6 +10,7 @@ import {
 /** @ts-ignore (not yet in types?) */
 import { BasicNodeLibrary } from "three";
 import * as Stats from 'three/examples/jsm/libs/stats.module.js';
+import type { EffectComposer as ThreeEffectComposer } from "three/examples/jsm/postprocessing/EffectComposer.js";
 import { nodeFrame } from "three/examples/jsm/renderers/webgl-legacy/nodes/WebGLNodeBuilder.js";
 
 import { isDevEnvironment, LogType, showBalloonError, showBalloonMessage } from './debug/index.js';
@@ -188,6 +189,10 @@ export class Context implements IContext {
 		ContextRegistry.Current = context;
 	}
 
+	static get All(): Context[] {
+		return ContextRegistry.All as Context[];
+	}
+
 	/** The name of the context */
 	name: string;
 	/** An alias for the context */
@@ -317,7 +322,7 @@ export class Context implements IContext {
 
 	scene: Scene;
 	renderer!: WebGLRenderer;
-	composer: EffectComposer | null = null;
+	composer: EffectComposer | ThreeEffectComposer | null = null;
 
 	// all scripts
 	readonly scripts: IComponent[] = [];
@@ -1450,7 +1455,7 @@ export class Context implements IContext {
 
 		if (this.composer && !this.isInXR) {
 			// if a camera is passed in we need to check if we need to update the composer's camera
-			if (camera) {
+			if (camera && "setMainCamera" in this.composer) {
 				const currentPassesCamera = this.composer.passes[0]?.mainCamera;
 				if (currentPassesCamera != camera)
 					this.composer.setMainCamera(camera);

package/src/engine/engine_context_registry.ts

@@ -1,5 +1,7 @@
 import { type IComponent, type IContext, type LoadedModel } from "./engine_types.js";
 
+const debug = typeof window !== undefined ? window.location.search.includes("debugcontext") : false;
+
 /** The various events that can be dispatched by a Needle Engine {@link IContext} instance
  */
 export enum ContextEvent {
@@ -62,6 +64,8 @@ export class ContextRegistry {
 
     /** @internal Internal use only */
     static register(ctx: IContext) {
+        if (this.Registered.indexOf(ctx) !== -1) return;
+        if (debug) console.warn("Registering context");
         this.Registered.push(ctx);
         this.dispatchCallback(ContextEvent.ContextRegistered, ctx);
     }
@@ -70,6 +74,7 @@ export class ContextRegistry {
     static unregister(ctx: IContext) {
         const index = this.Registered.indexOf(ctx);
         if (index === -1) return;
+        if (debug) console.warn("Unregistering context");
         this.Registered.splice(index, 1);
     }
 

package/src/engine/engine_texture.ts

@@ -1,5 +1,6 @@
 import type { EffectComposer } from "postprocessing";
 import { Camera, Mesh, Object3D, Texture, WebGLRenderer, WebGLRenderTarget } from "three";
+import type { EffectComposer as ThreeEffectComposer } from "three/examples/jsm/postprocessing/EffectComposer";
 
 import { findResourceUsers } from "./engine_assetdatabase.js";
 
@@ -27,9 +28,9 @@ export class RenderTexture extends WebGLRenderTarget {
      * @param camera The camera to render from
      * @param renderer The renderer or effectcomposer to use
      */
-    render(scene: Object3D, camera: Camera, renderer: WebGLRenderer | EffectComposer) {
+    render(scene: Object3D, camera: Camera, renderer: WebGLRenderer | EffectComposer | ThreeEffectComposer) {
 
-        const composer = renderer as EffectComposer;
+        const composer = renderer as (EffectComposer | ThreeEffectComposer);
 
         if ("addPass" in composer) {
             if (!this["_unsupported_effectcomposer_warning"]) {

package/src/engine/engine_tonemapping.ts

@@ -87,8 +87,8 @@ vec3 _agx(vec3 val) {
         0.0784335999999992,  0.878468636469772,  0.0784336,
         0.0792237451477643, 0.0791661274605434, 0.879142973793104);
     
-    const float min_ev = -12.47393f;
-    const float max_ev = 4.026069f;
+    const float min_ev = -12.47393;
+    const float max_ev = 4.026069;
 
     // val = pow(val, vec3(2.2)); 
 

package/src/engine/engine_utils_format.ts

@@ -61,7 +61,11 @@ export async function tryDetermineFileTypeFromURL(url: string, useExtension: boo
 
     // If the URL doesnt contain a filetype we need to check the header
     // This is the case for example if we load a file from a data url
-    const header = await fetch(url, {
+    const newUrl = new URL(url);
+    // Adding a URL parameter to avoid the brower to bust the full cache
+    // If we don't do this the file that might already be disc cached will be deleted from the cache
+    newUrl.searchParams.append("range", "true");
+    const header = await fetch(newUrl, {
         method: "GET",
         headers: {
             "range": "bytes=0-32"

package/src/engine-components/Skybox.ts

@@ -5,7 +5,7 @@ import { KTX2Loader } from "three/examples/jsm/loaders/KTX2Loader.js";
 import { RGBELoader } from 'three/examples/jsm/loaders/RGBELoader.js';
 
 import { disposeObjectResources, setDisposable } from "../engine/engine_assetdatabase.js";
-import { ContextRegistry } from "../engine/engine_context_registry.js";
+import { ContextEvent, ContextRegistry } from "../engine/engine_context_registry.js";
 import { registerObservableAttribute } from "../engine/engine_element_extras.js";
 import { syncField } from "../engine/engine_networking_auto.js";
 import { serializable } from "../engine/engine_serialization_decorator.js";
@@ -39,11 +39,11 @@ function createRemoteSkyboxComponent(context: IContext, url: string, skybox: boo
     return remote.setSkybox(url);
 }
 
-ContextRegistry.addContextCreatedCallback((args) => {
+const promises = new Array<Promise<any>>();
+ContextRegistry.registerCallback(ContextEvent.ContextCreationStart, (args) => {
     const context = args.context;
     const skyboxImage = context.domElement.getAttribute("skybox-image") || context.domElement.getAttribute("background-image");
     const environmentImage = context.domElement.getAttribute("environment-image");
-    const promises = new Array<Promise<any>>();
     if (skyboxImage) {
         if (debug)
             console.log("Creating remote skybox to load " + skyboxImage);
@@ -60,10 +60,11 @@ ContextRegistry.addContextCreatedCallback((args) => {
         const promise = createRemoteSkyboxComponent(context, environmentImage, false, true, "environment-image");
         promises.push(promise);
     }
-    if (promises.length > 0) {
-        return PromiseAllWithErrors(promises);
-    }
-    return Promise.resolve();
+});
+ContextRegistry.registerCallback(ContextEvent.ContextCreationStart, () => {
+    return Promise.all(promises).finally(() => {
+        promises.length = 0;
+    })
 });
 
 declare type SkyboxCacheEntry = { src: string, texture: Promise<Texture> };