@needle-tools/engine 3.5.5-alpha.1 → 3.5.7-alpha

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@needle-tools/engine",
-    "version": "3.5.5-alpha.1",
+    "version": "3.5.7-alpha",
     "description": "Needle Engine is a web-based runtime for 3D apps. It runs on your machine for development with great integrations into editors like Unity or Blender - and can be deployed onto any device! It is flexible, extensible and networking and XR are built-in",
     "main": "dist/needle-engine.umd.cjs",
     "type": "module",
@@ -20,8 +20,9 @@
     "scripts": {
         "dev": "npm-watch",
         "font:generate": "node plugins/generate-font.js",
-        "build": "npm run build:dist && npm run build:src",
+        "build": "npm run build:dist && npm run build:dist:light && npm run build:src",
         "build:dist": "vite build",
+        "build:dist:light": "vite build -- --light --noclear",
         "build:src": "tsc --outDir ./lib --noEmit false --declaration",
         "build:license": "node plugins/publish/create-license.mjs",
         "test:circular-imports": "node plugins/check-circular-imports.js",

package/src/engine/engine_addressables.ts

@@ -212,7 +212,6 @@ export class AssetReference {
 
     private async onInstantiate(parent?: Object3D | InstantiateOptions, networked: boolean = false, saveOnServer?: boolean) {
         const context = Context.Current;
-        if (!parent) parent = context.scene;
         if (this.mustLoad) {
             await this.loadAssetAsync();
         }
@@ -235,6 +234,7 @@ export class AssetReference {
                     Object.assign(options, parent);
                 }
             }
+            if (!options.parent) options.parent = context.scene;
 
             let count = AssetReference.currentlyInstantiating.get(this.uri);
             // allow up to 10000 instantiations of the same prefab in the same frame

package/src/engine/engine_components.ts

@@ -75,20 +75,25 @@ export function addNewComponent<T extends IComponent>(obj: Object3D, componentIn
 }
 
 export function moveComponentInstance(obj: Object3D, componentInstance: IComponent) {
-    if (componentInstance.gameObject === obj) return;
+    if (componentInstance.gameObject === obj) return componentInstance;
     // TODO: update raycast array
     if (componentInstance.gameObject && componentInstance.gameObject.userData.components) {
         const index = componentInstance.gameObject.userData.components.indexOf(componentInstance);
         componentInstance.gameObject.userData.components.splice(index, 1);
     }
     if (!obj.userData.components) obj.userData.components = [];
-    else if (obj.userData.components.includes(componentInstance)) return;
+    else if (obj.userData.components.includes(componentInstance)) return componentInstance;
     // TODO: do we want to disable and enable when moving?
     // componentInstance.__internalDisable();
     obj.userData.components.push(componentInstance);
     componentInstance.gameObject = obj as IGameObject;
     // componentInstance.__internalEnable();
     // componentInstance.transform = obj;
+    if (componentInstance.guid === undefined || componentInstance.guid === "invalid") {
+        componentInstance.guid = idProvider.generateUUID();
+    }
+    registerComponent(componentInstance);
+    return componentInstance;
 }
 
 

package/src/engine/engine_networking.ts

@@ -1,7 +1,5 @@
-// import geckos, { ClientChannel, Data } from '@geckos.io/client';
-
-// const serverUrl = 'wss://tiny-server-1-r26roub2hq-ew.a.run.app/';
-let serverUrl = 'wss://needle-tiny-starter.glitch.me/socket';
+const defaultNetworkingBackendUrlProvider = "https://urls.needle.tools/default-networking-backend/index";
+let serverUrl : string | undefined = "wss://needle-tiny-starter.glitch.me/socket";
 
 import { Websocket, WebsocketBuilder } from 'websocket-ts';
 // import { Networking } from '../engine-components/Networking';
@@ -85,6 +83,8 @@ declare type OwnershipResponse = {
     value: boolean;
 }
 
+declare type WebsocketSendType = IModel | object | boolean | null | string | number;
+
 export class OwnershipModel {
 
     public guid: string;
@@ -308,8 +308,9 @@ export class NetworkConnection implements INetworkConnection {
         this.send(RoomEvents.Leave, { room: room });
     }
 
-    public send(key: string | OwnershipEvent, data: IModel | object | boolean | null | string | number = null, queue: SendQueue = SendQueue.Queued) {
+    public send<T extends WebsocketSendType>(key: string | OwnershipEvent, data: T | null = null, queue: SendQueue = SendQueue.Queued) {
 
+        //@ts-ignore
         if (data === null) data = {};
 
         if (queue === SendQueue.Queued) {
@@ -331,7 +332,7 @@ export class NetworkConnection implements INetworkConnection {
         delete this._state[guid];
     }
 
-    public sendDeleteRemoteStateAll(){
+    public sendDeleteRemoteStateAll() {
         this.send("delete-all-state");
         this._state = {};
     }
@@ -404,23 +405,25 @@ export class NetworkConnection implements INetworkConnection {
         this.netWebSocketUrlProvider = prov;
     }
 
-    public connect() {
-        if (this.connected) return;
+    public async connect() {
+        if (this.connected) return Promise.resolve(true);
         if (debugNet)
             console.log("connecting");
-        // this.channel = geckos({ port: 9208, url: 'http://127.0.0.1' });
-        // this.channel.onConnect(this.onConnectGeckosIo.bind(this));
-        // const networking = GameObject.findObjectOfType(Networking, this.context, false);
         const overrideUrl = this.netWebSocketUrlProvider?.getWebsocketUrl();
         if (overrideUrl) {
             serverUrl = overrideUrl;
         }
-        else if(isHostedOnGlitch()) {
+        else if (isHostedOnGlitch()) {
             serverUrl = "wss://" + window.location.host + "/socket";
         }
-        this.connectWebsocket();
+        return this.connectWebsocket();
     };
 
+    public disconnect() {
+        this._ws?.close();
+        this._ws = undefined;
+    }
+
     private _listeners: { [key: string]: Function[] } = {};
     private _listenersBinary: { [key: string]: BinaryCallback[] } = {};
     private connected: boolean = false;
@@ -428,7 +431,6 @@ export class NetworkConnection implements INetworkConnection {
     private _connectionId: string | null = null;
 
     // Websocket ------------------------------------------------------------
-    private _isConnectingToWebsocket: boolean = false;
     private _ws: Websocket | undefined;
     private _waitingForSocket: { [key: string]: Array<Function> } = {};
     private _isInRoom: boolean = false;
@@ -439,26 +441,55 @@ export class NetworkConnection implements INetworkConnection {
     private _state: { [key: string]: any } = {};
     private _currentDelay: number = -1;
 
+    private _connectingToWebsocketPromise: Promise<boolean> | null = null;
+
     private connectWebsocket() {
-        if (this._isConnectingToWebsocket) return;
-        this._isConnectingToWebsocket = true;
-        console.log("Connecting to " + serverUrl)
-        const ws = new WebsocketBuilder(serverUrl)
-            .onOpen(() => {
-                this._ws = ws;
-                this._isConnectingToWebsocket = false;
-                this.connected = true;
-                console.log("Connected to websocket");
-                this.onSendQueued(SendQueue.OnConnection);
-            })
-            .onClose((_evt) => {
-                this.connected = false;
-                this._isInRoom = false;
-            })
-            .onError((i, ev) => { console.error(i, ev) })
-            .onMessage(this.onMessage.bind(this))
-            .onRetry(() => { console.log("websocket connection retry") })
-            .build();
+        if (this._connectingToWebsocketPromise) return this._connectingToWebsocketPromise;
+        return this._connectingToWebsocketPromise = new Promise(async (res, _) => {
+            let didResolve = false;
+            const resolve = (val: boolean) => {
+                if (didResolve) return;
+                didResolve = true;
+                res(val);
+            }
+            if(serverUrl === undefined){
+                console.log("Fetch default backend url: " + defaultNetworkingBackendUrlProvider);
+                let failed = false;
+                const defaultUrlResponse = await fetch(defaultNetworkingBackendUrlProvider);
+                serverUrl = await defaultUrlResponse.text();
+                if(failed) return;
+            }
+
+            if(serverUrl === undefined){
+                resolve(false);
+                return;
+            }
+
+            console.log("⊡ Connecting to networking backend on\n" + serverUrl)
+            const ws = new WebsocketBuilder(serverUrl)
+                .onOpen(() => {
+                    this._connectingToWebsocketPromise = null;
+                    this._ws = ws;
+                    this.connected = true;
+                    console.log("⊞ Connected to networking backend\n" + serverUrl);
+                    resolve(true);
+                    this.onSendQueued(SendQueue.OnConnection);
+                })
+                .onClose((_evt) => {
+                    this._connectingToWebsocketPromise = null;
+                    this.connected = false;
+                    this._isInRoom = false;
+                    resolve(false);
+                })
+                .onError((i, ev) => {
+                    console.error("⊠ Websocket error", i, ev);
+                    resolve(false);
+                })
+                .onMessage(this.onMessage.bind(this))
+                .onRetry(() => { console.log("Retry connecting to networking websocket") })
+                .build();
+
+        });
     }
 
     private onMessage(_, ev) {
@@ -575,7 +606,7 @@ export class NetworkConnection implements INetworkConnection {
                     break;
 
                 case "all-room-state-deleted":
-                    if(debugNet) console.log("RECEIVED all-room-state-deleted");
+                    if (debugNet) console.log("RECEIVED all-room-state-deleted");
                     this._state = {};
                     break;
 

package/src/engine-components/Component.ts

@@ -273,8 +273,10 @@ export abstract class GameObject extends Object3D implements Object3D, IGameObje
 
     // these are implemented via threejs object extensions
     abstract activeSelf: boolean;
+    /** creates a new component on this gameObject */
     abstract addNewComponent<T>(type: Constructor<T>): T | null;
-    // TODO: add method for addExisting component
+    /** adds an existing component to this gameObject */
+    abstract addComponent(comp: IComponent): void;
     abstract removeComponent(comp: Component): Component;
     abstract getOrAddComponent<T>(typeName: Constructor<T> | null): T;
     abstract getComponent<T>(type: Constructor<T>): T | null;