Needle Engine 3.22.1

Files changed (5) hide show

src/engine/engine_context.ts +1 -1
src/engine/engine_license.ts +4 -4
src/engine/engine_networking.ts +39 -0
src/engine/codegen/register_types.ts +2 -2
src/engine-components/ScreenCapture.ts +36 -13

src/engine/engine_context.ts CHANGED Viewed

@@ -951,7 +951,7 @@
 		this._currentFrameEvent = FrameEvent.Undefined;
-		if (this.isInXR === false && this.targetFrameRate !== undefined) {
+		if (this.isManagedExternally === false && this.isInXR === false && this.targetFrameRate !== undefined) {
 			if (this._lastTimestamp === 0) this._lastTimestamp = timestamp;
 			this._accumulatedTime += (timestamp - this._lastTimestamp) / 1000;
 			this._lastTimestamp = timestamp;

src/engine/engine_license.ts CHANGED Viewed

@@ -50,7 +50,6 @@
             const licenseUrl = "https://engine.needle.tools/licensing/check?location=" + encodeURIComponent(window.location.href) + "&version=" + VERSION + "&generator=" + encodeURIComponent(GENERATOR);
             const res = await fetch(licenseUrl, {
                 method: "GET",
-                mode: "no-cors",
             }).catch();
             if (res?.status === 200) {
                 applicationIsForbidden = false;
@@ -226,12 +225,13 @@
         margin-top: .3em;
         margin-bottom: .5em;
         padding: .2em;
-        padding-left: 37px;
+        padding-left: 25px;
         border-radius: .5em;
-        border: 2px solid rgba(160,160,160,.5);
+        border: 2px solid rgba(160,160,160,.3);
     `;
     // url must contain https for firefox to make it clickable
-    const licenseText = "Needle Engine — No license active, commercial use is not allowed. Visit https://needle.tools/pricing for more information and licensing options.";
+    const version = VERSION;
+    const licenseText = `Needle Engine — No license active, commercial use is not allowed. Visit https://needle.tools/pricing for more information and licensing options! v${version}`;
     console.log("%c " + licenseText, style);
 }

src/engine/engine_networking.ts CHANGED Viewed

@@ -28,20 +28,32 @@
     room: string | undefined;
 }
+/** Events regarding the websocket connection (e.g. when the connection opens) */
 export enum ConnectionEvents {
     ConnectionInfo = "connection-start-info"
 }
+/** Use to listen to room networking events like joining a networked room
+ *  For example: `this.context.connection.beginListen(RoomEvents.JoinedRoom, () => { })`
+ * @link https://engine.needle.tools/docs/networking.html#manual-networking
+ * */
 export enum RoomEvents {
+    /** Internal: sent to the server when attempting to join a room */
     Join = "join-room",
+    /** Internal: sent to the server when attempting to leave a room */
     Leave = "leave-room",
+    /** Incoming: When the local user has joined a room */
     JoinedRoom = "joined-room",
+    /** Incoming: When the local user has left a room */
     LeftRoom = "left-room",
+    /** Incoming: When a other user has joined the room */
     UserJoinedRoom = "user-joined-room",
+    /** Incoming: When a other user has left the room */
     UserLeftRoom = "user-left-room",
     RoomStateSent = "room-state-sent",
 }
+/** Received when listening to `RoomEvents.JoinedRoom` event */
 export class JoinedRoomResponse {
     room!: string; // room name
     viewId!: string;
@@ -57,6 +69,8 @@
     userId!: string;
 }
+/** The Needle Engine networking server supports the concept of ownership that can be requested. The `OwnershipEvent` enum contains possible outgoing (Request) and incoming (Response) events for communicating ownership.
+ * We recommend using the `OwnershipModel` class instead of dealing with those events directly tho. */
 export enum OwnershipEvent {
     RequestHasOwner = 'request-has-owner',
     ResponseHasOwner = "response-has-owner",
@@ -86,6 +100,7 @@
 declare type WebsocketSendType = IModel | object | boolean | null | string | number;
+/** Class for abstracting the concept of ownership regarding a networked object or component. A component that is owned by another user can not be modified through networking (the server will reject changes) */
 export class OwnershipModel {
     public guid: string;
@@ -229,6 +244,7 @@
     (data: any | flatbuffers.ByteBuffer): void;
 }
+/** Main class to communicate with the networking backend */
 export class NetworkConnection implements INetworkConnection {
     private context: Context;
@@ -251,6 +267,7 @@
         return this._state[guid];
     }
+    /** The connection id of the local user - it is given by the networking backend and can not be changed */
     public get connectionId(): string | null {
         return this._connectionId;
     }
@@ -259,32 +276,40 @@
         return debugNet;
     }
+    /** True when connected to the networking backend */
     public get isConnected(): boolean {
         return this.connected;
     }
+    /** The name of the room the user is currently connected to */
     public get currentRoomName(): string | null { return this._currentRoomName; }
+    /** True when connected to a room via a regular url, otherwise (when using a view only url) false indicating that the user should not be able to modify the scene */
     public get allowEditing(): boolean { return this._currentRoomAllowEditing; }
     // use this to join a room in view mode (see SyncedRoom)
     public get currentRoomViewId(): string | null { return this._currentRoomViewId; }
+    /** True if connected to a networked room. Use the joinRoom function or a `SyncedRoom` component */
     public get isInRoom(): boolean {
         return this._isInRoom;
     }
+    /** Latency to currently connected backend server */
     public get currentLatency(): number {
         return this._currentDelay;
     }
+    /** A ping is sent to the server at a regular interval while the browser tab is active. This method can be used to send additional ping messages when needed so that the user doesn't get disconnected from the networking backend */
     public sendPing() {
         this.send("ping", { time: this.context.time.time });
     }
+    /** Returns true if a user with the given connectionId is in the room */
     public userIsInRoom(id: string): boolean {
         return this._currentInRoom.indexOf(id) !== -1;
     }
     private _usersInRoomCopy = [];
+    /** Returns a list of all user ids in the current room */
     public usersInRoom(target: string[] | null = null): string[] {
         if (!target) target = this._usersInRoomCopy;
         target.length = 0;
@@ -293,6 +318,7 @@
         return target;
     }
+    /** Joins a networked room. If you don't want to manage a connection yourself you can use a `SyncedRoom` component as well */
     public joinRoom(room: string, viewOnly: boolean = false): boolean {
         if (!room) {
             console.error("Missing room name, can not join: \"" + room + "\"");
@@ -312,6 +338,7 @@
         return true;
     }
+    /** Use to leave a room that you are currently connected to (use `leaveRoom()` to disconnect from the currently active room but you can also specify a room name) */
     public leaveRoom(room: string | null = null) {
         if (!room) room = this.currentRoomName;
         if (!room) {
@@ -322,6 +349,7 @@
         return true;
     }
+    /** Send a message to the networking backend - it will broadcasted to all connected users in the same room by default */
     public send<T extends WebsocketSendType>(key: string | OwnershipEvent, data: T | null = null, queue: SendQueue = SendQueue.Queued) {
         //@ts-ignore
@@ -341,16 +369,19 @@
         return this.sendWithWebsocket(key, data, queue);
     }
+    /** Use to delete state for a given guid on the server */
     public sendDeleteRemoteState(guid: string) {
         this.send("delete-state", { guid: guid, dontSave: true });
         delete this._state[guid];
     }
+    /** Use to delete all state in the currently connected room on the server */
     public sendDeleteRemoteStateAll() {
         this.send("delete-all-state");
         this._state = {};
     }
+    /** Send a binary message to the server (broadcasted to all connected users) */
     public sendBinary(bin: Uint8Array) {
         if (debugNet) console.log("<< bin", bin.length);
         this._ws?.send(bin);
@@ -380,6 +411,7 @@
         this._ws?.send(message);
     }
+    /** Use to start listening to networking events */
     public beginListen(key: string | OwnershipEvent, callback: Function): Function {
         if (!this._listeners[key])
             this._listeners[key] = [];
@@ -389,6 +421,8 @@
     /**@deprecated please use stopListen instead (2.65.2-pre) */
     public stopListening(key: string | OwnershipEvent, callback: Function | null) { return this.stopListen(key, callback); }
+    /** Use to stop listening to networking events */
     public stopListen(key: string | OwnershipEvent, callback: Function | null) {
         if (!callback) return;
         if (!this._listeners[key]) return;
@@ -398,6 +432,7 @@
         }
     }
+    /** Use to start listening to networking binary events */
     public beginListenBinary(identifier: string, callback: BinaryCallback): BinaryCallback {
         if (!this._listenersBinary[identifier])
             this._listenersBinary[identifier] = [];
@@ -405,6 +440,7 @@
         return callback;
     }
+    /** Use to stop listening to networking binary events */
     public stopListenBinary(identifier: string, callback: any) {
         if (!this._listenersBinary[identifier]) return;
         const index = this._listenersBinary[identifier].indexOf(callback);
@@ -415,10 +451,12 @@
     private netWebSocketUrlProvider?: INetworkingWebsocketUrlProvider;
+    /** Use to override the networking server backend url. This is what the `Networking` component uses to modify the backend url */
     public registerProvider(prov: INetworkingWebsocketUrlProvider) {
         this.netWebSocketUrlProvider = prov;
     }
+    /** Used to connect to the networking server */
     public async connect() {
         if (this.connected) return Promise.resolve(true);
         if (debugNet)
@@ -433,6 +471,7 @@
         return this.connectWebsocket();
     };
+    /** Used to disconnect from the networking server */
     public disconnect() {
         this._ws?.close();
         this._ws = undefined;

src/engine/codegen/register_types.ts CHANGED Viewed

@@ -1,5 +1,5 @@
 import { TypeStore } from "./../engine_typestore.js"
 // Import types
 import { __Ignore } from "../../engine-components/codegen/components.js";
 import { ActionBuilder } from "../../engine-components/export/usdz/extensions/behavior/BehavioursBuilder.js";
@@ -217,7 +217,7 @@
 import { XRGrabRendering } from "../../engine-components/webxr/WebXRGrabRendering.js";
 import { XRRig } from "../../engine-components/webxr/WebXRRig.js";
 import { XRState } from "../../engine-components/XRFlag.js";
 // Register types
 TypeStore.add("__Ignore", __Ignore);
 TypeStore.add("ActionBuilder", ActionBuilder);

src/engine-components/ScreenCapture.ts CHANGED Viewed

@@ -3,7 +3,7 @@
 import { serializable } from "../engine/engine_serialization.js";
 import type { IPointerClickHandler, PointerEventData } from "./ui/PointerEvents.js";
 import { AudioSource } from "./AudioSource.js";
-import { getParam } from "../engine/engine_utils.js";
+import { delay, getParam } from "../engine/engine_utils.js";
 import { showBalloonWarning } from "../engine/debug/index.js";
 import { NetworkedStreams, disposeStream, StreamReceivedEvent, StreamEndedEvent, PeerHandle, NetworkedStreamEvents } from "../engine/engine_networking_streams.js";
 import { RoomEvents } from "../engine/engine_networking.js";
@@ -52,7 +52,6 @@
     onPointerClick(evt: PointerEventData) {
         if (!this.allowStartOnClick) return;
         if (evt && evt.pointerId !== 0) return;
-        if (this.context.connection.isInRoom === false) return;
         if (this.isReceiving && this.videoPlayer?.isPlaying) {
             if (this.videoPlayer)
                 this.videoPlayer.screenspace = !this.videoPlayer.screenspace;
@@ -127,9 +126,9 @@
         if (debug)
             console.log("Screensharing", this.name, this);
         AudioSource.registerWaitForAllowAudio(() => {
-            if (this.videoPlayer && this._currentStream && this._currentMode === ScreenCaptureMode.Receiving) {
-                this.videoPlayer.playInBackground = true;
-                this.videoPlayer.setVideo(this._currentStream);
+            if (this._videoPlayer && this._currentStream && this._currentMode === ScreenCaptureMode.Receiving) {
+                this._videoPlayer.playInBackground = true;
+                this._videoPlayer.setVideo(this._currentStream);
             }
         });
         const handle = PeerHandle.getOrCreate(this.context, this.guid);
@@ -143,8 +142,11 @@
         //@ts-ignore
         this._net?.addEventListener(NetworkedStreamEvents.StreamEnded, this.onCallEnded);
         this.context.connection.beginListen(RoomEvents.JoinedRoom, this.onJoinedRoom);
-        if (this.context.connection.isInRoom && this.autoConnect) {
-            this.share();
+        if (this.autoConnect) {
+            delay(1000).then(() => {
+                if (this.enabled && this.autoConnect && !this.isReceiving && !this.isSending && this.context.connection.isInRoom)
+                    this.share()
+            });
         }
     }
@@ -158,15 +160,37 @@
         this.close();
     }
-    private onJoinedRoom = () => {
-        if (this.autoConnect && !this.isSending && !this.isReceiving) {
+    private onJoinedRoom = async () => {
+        await delay(1000);
+        if (this.autoConnect && !this.isSending && !this.isReceiving && this.context.connection.isInRoom) {
             this.share();
         }
     }
+    private _ensureVideoPlayer() {
+        const vp = new VideoPlayer();
+        vp.aspectMode = AspectMode.AdjustWidth;
+        GameObject.addComponent(this.gameObject, vp);
+        this._videoPlayer = vp;
+    }
+    private _activeShareRequest: Promise<void> | null = null;
     /** Call to begin screensharing */
     async share(opts?: ScreenCaptureOptions) {
+        if (this._activeShareRequest) return this._activeShareRequest;
+        this._activeShareRequest = this.internalShare(opts);
+        return this._activeShareRequest.then(() =>{
+            this._activeShareRequest = null;
+        })
+    }
+    private async internalShare(opts?: ScreenCaptureOptions) {
+        if (this.context.connection.isInRoom === false) {
+            console.warn("Can not start screensharing: requires network connection");
+            return;
+        }
         if (opts?.device)
             this.device = opts.device;
@@ -175,10 +199,7 @@
                 this._videoPlayer = GameObject.getComponent(this.gameObject, VideoPlayer) ?? undefined;
             }
             if (!this.videoPlayer) {
-                const vp = new VideoPlayer();
-                vp.aspectMode = AspectMode.AdjustWidth;
-                GameObject.addComponent(this.gameObject, vp);
-                this._videoPlayer = vp;
+                this._ensureVideoPlayer();
             }
             if (!this.videoPlayer) {
                 console.warn("Can not share video without a videoPlayer assigned");
@@ -297,6 +318,8 @@
         const isSending = mode === ScreenCaptureMode.Sending;
         if (isVideoStream) {
+            if (!this._videoPlayer)
+                this._ensureVideoPlayer();
             if (this._videoPlayer)
                 this._videoPlayer.setVideo(stream);
             else console.error("No video player assigned for video stream");