teleportxr 1.0.95 → 1.0.97

package/client/client.js

@@ -431,6 +431,11 @@ class Client {
 		{
 			this.SendNode(uid);
 		}
+		var remove_nodes_uids=this.geometryService.GetRemoveNodesToSend();
+		if (remove_nodes_uids.length)
+		{
+			this.SendRemoveNodes(remove_nodes_uids);
+		}
 		var mesh_uids=this.geometryService.GetMeshesToSend();
 		for (const uid of mesh_uids)
 		{
@@ -599,7 +604,41 @@ class Client {
 		if(sendSuccess)
 			this.geometryService.EncodedResource(uid);
 	}
-	//! For a cubemap resource, return the URL of the variant matching this client's axes
+	//! Tell the client to destroy the given nodes (RemoveNodes payload). If the
+	//! geometry channel is not open the uids are re-queued so the next tick retries.
+	SendRemoveNodes(uids)
+	{
+		if(!this.webRtcConnection)
+		{
+			console.error("Client "+this.clientID+", SendRemoveNodes: this.webRtcConnection is null");
+			for (const uid of uids)
+				this.geometryService.removedNodesToSend.add(uid);
+			return;
+		}
+		if(!this.webRtcConnection.isGeometryOpen())
+		{
+			// Channel not yet open; re-queue so it retries on the next tick.
+			for (const uid of uids)
+				this.geometryService.removedNodesToSend.add(uid);
+			return;
+		}
+		const buffer = new ArrayBuffer(8+1+2+uids.length*8);
+		const size=node_encoder.encodeRemoveNodes(uids,buffer);
+		const view2 = new DataView(buffer, 0, size);
+		const sendSuccess = this.webRtcConnection.sendGeometry(view2);
+		console.log("[T+"+this.elapsedMsSinceStart()+"ms, conn+"+this.elapsedMsSinceConnected()+"ms] Sending RemoveNodes ["+uids.join(", ")+"] to Client "+this.clientID+", size: "+size+" bytes — "+
+			(sendSuccess ? "OK" : "FAILED"));
+		if(sendSuccess)
+		{
+			for (const uid of uids)
+				this.geometryService.EncodedResource(uid);
+		}
+		else
+		{
+			for (const uid of uids)
+				this.geometryService.removedNodesToSend.add(uid);
+		}
+	}
 	//! standard (e.g. /envCloudyCubemap.ktx2 -> /envCloudyCubemap_ogl.ktx2). Returns undefined
 	//! to mean "use the resource's base url" — for non-cubemaps, unknown axes standards, or
 	//! when the variant file is missing under the public path (so streaming never breaks).

package/client/client_manager.js

@@ -13,6 +13,7 @@ class ClientManager
 		this.clients= new Map();
 		this.addClientNodeAndReturnOriginUid=null;
 		this.onClientPostCreate=null;
+		this.onClientDisconnect=null;
 		this.geometryIntervalId=0;
 		let unixt_us=core.getStartTimeUnixUs();
 		console.log("Start Time: "+unixt_us+" us = "+core.unixTimeToUTCString(unixt_us)+"\n");
@@ -81,6 +82,11 @@ class ClientManager
 	RemoveClient(clientID){
         if(this.clients.has(clientID)) {
 			this.clients.delete(clientID);
+			// Notify the host application after removal, so per-client state
+			// (e.g. avatar nodes) can be torn down while this client is gone
+			// from the map but the remaining clients are still iterable.
+			if(this.onClientDisconnect!=null)
+				this.onClientDisconnect(clientID);
 			if(this.clients.size==0)
 				this.StopStreaming();
 		}
@@ -106,6 +112,10 @@ class ClientManager
 	{
 		this.onClientPostCreate=cb;
 	}
+	SetClientDisconnectionCallback(cb)
+	{
+		this.onClientDisconnect=cb;
+	}
 	// This is a callback, signaling service calls this when the client has signalled.
 	newClient(clientID, signalingClient) {
 		// then we tell the client manager to start this client.

package/client/geometry_service.js

@@ -88,6 +88,9 @@ class GeometryService {
 		this.streamedAnimations = new Map();
 		this.streamedTextCanvases = new Map();
 		this.streamedFontAtlases = new Map();
+		// Nodes that were streamed to this client and have since been unstreamed.
+		// Drained by GetRemoveNodesToSend() and sent as a RemoveNodes payload.
+		this.removedNodesToSend = new Set();
 
 		this.backgroundTextureUid = 0;
 		// ten seconds for timeout. Tweak this.
@@ -128,6 +131,11 @@ class GeometryService {
 				return;
 			}
 			res.clientNeeds.set(index, false);
+			// If the node was actually sent to this client, the client must be
+			// told to destroy it via a RemoveNodes payload.
+			if (res.WasSentToClient(this.clientID)) {
+				this.removedNodesToSend.add(uid);
+			}
 		}
 		// Should certainly be in this set:
 		this.nodesToStreamEventually.delete(uid);
@@ -136,6 +144,14 @@ class GeometryService {
 		// TODO: now reduce the counts for all the dependent resources.
 		console.log("Unstreaming node ", uid," for client ", this.clientID);
 	}
+	//! Drain the set of nodes the client must destroy. Returns an array of uids;
+	//! the caller re-queues via UnstreamNode semantics if the send fails.
+	GetRemoveNodesToSend() {
+		if (this.removedNodesToSend.size == 0) return [];
+		var uids = Array.from(this.removedNodesToSend);
+		this.removedNodesToSend.clear();
+		return uids;
+	}
 	StreamOrUnstream(resourceMap, uid, diff) {
 		// exclude "undefined"
 		if (!uid) return;

package/connections/webrtcconnection.js

@@ -113,6 +113,16 @@ class WebRtcConnection extends EventEmitter
 	}
 	reconnect()
 	{
+		// A browser peer that has already accepted an SDP with N m-sections will
+		// reject any later offer with fewer (RTCPeerConnection throws "New remote
+		// description has fewer m-sections than the previous remote description"),
+		// tearing down the whole connection. Recreating the PeerConnection below
+		// starts with zero transceivers, so remember which per-node audio sources
+		// were live beforehand and re-add matching ones on the new PeerConnection
+		// (below) before the next offer goes out, keeping the m-section count from
+		// shrinking relative to what the browser already negotiated.
+		const previousAudioSourceUids = this.getNodeAudioSourceUids();
+
 		// Close and clean up the previous PeerConnection before creating a new one.
 		// Failing to do so leaves the old ICE agent (and its UDP socket) alive, which
 		// causes it to keep sending/receiving STUN messages with stale credentials and
@@ -136,6 +146,8 @@ class WebRtcConnection extends EventEmitter
 		// the previous PeerConnection's lifetime suppresses UpdateStreaming kick.
 		this._dataChannelsOpenFired = false;
 		this.beforeOffer();
+		for (const uid of previousAudioSourceUids)
+			this.addNodeAudioSource(uid);
 		this.connectionTimer = this.options.setTimeout(() =>
 		{
 			if (this.peerConnection.iceConnectionState !== 'connected'

package/core/core.js

@@ -340,6 +340,7 @@ const GeometryPayloadType =
 	TexturePointer: 10,
 	MeshPointer: 11,
 	MaterialPointer: 12,
+	RemoveNodes: 13,
 };
 
 class DisplayInfo {

package/package.json

@@ -16,7 +16,7 @@
   },
   "name": "teleportxr",
   "description": "Teleport Spatial Server on node.js",
-  "version": "1.0.95",
+  "version": "1.0.97",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/simul/teleport-nodejs.git"

package/protocol/encoders/node_encoder.js

@@ -29,4 +29,23 @@ function encodeNode(node,buffer,fromAxes,toAxes)
 	dataView.setBigUint64(0,BigInt(byteOffset-8),core.endian);
 	return byteOffset;
 }
-module.exports= {encodeNode};
+
+// Encode a RemoveNodes payload: uint8 payload type, uint16 count, then count
+// uint64 node uids (matches GeometryEncoder::encodeRemoveNodes on the C++ server
+// and GeometryDecoder::decodeRemoveNodes on the client). Returns the size written.
+function encodeRemoveNodes(node_uids,buffer)
+{
+	var byteOffset=0;
+	const dataView = new DataView(buffer);
+	byteOffset=putPlaceholderSize(dataView);
+
+	byteOffset=core.put_uint8(dataView,byteOffset,core.GeometryPayloadType.RemoveNodes);
+	byteOffset=core.put_uint16(dataView,byteOffset,node_uids.length);
+	for (var i=0;i<node_uids.length;i++)
+	{
+		byteOffset=core.put_uint64(dataView,byteOffset,node_uids[i]);
+	}
+	dataView.setBigUint64(0,BigInt(byteOffset-8),core.endian);
+	return byteOffset;
+}
+module.exports= {encodeNode,encodeRemoveNodes};

package/scene/scene.js

@@ -52,6 +52,13 @@ class Scene {
 		this.nodes.set(uid, newNode);
 		return uid;
 	}
+	//! Remove a node from the scene (e.g. a session-scoped avatar node whose
+	//! owning client has disconnected). Returns true if the node was present.
+	//! Callers must UnstreamNode(uid) for any clients that received it, so they
+	//! are sent a RemoveNodes payload.
+	RemoveNode(uid) {
+		return this.nodes.delete(uid);
+	}
 	GetAllNodeUids() {
 		let node_uids = Array.from(this.nodes.keys());
 		return node_uids;

package/test/test_remove_nodes.js

@@ -0,0 +1,85 @@
+'use strict';
+// Tests for the RemoveNodes geometry payload: the encoder's byte layout must
+// match the C++ wire format (GeometryEncoder::encodeRemoveNodes /
+// GeometryDecoder::decodeRemoveNodes), and GeometryService.UnstreamNode must
+// queue a removal only for nodes that were actually sent to the client.
+
+const test = require('node:test');
+const assert = require('node:assert');
+const core = require('../core/core.js');
+const { encodeRemoveNodes } = require('../protocol/encoders/node_encoder.js');
+const { GeometryService } = require('../client/geometry_service');
+
+test('encodeRemoveNodes produces size-prefixed payload matching the C++ wire format', () => {
+	const uids = [5n, 7n];
+	const buffer = new ArrayBuffer(8 + 1 + 2 + uids.length * 8);
+	const size = encodeRemoveNodes(uids, buffer);
+	assert.strictEqual(size, 8 + 1 + 2 + 16);
+
+	const dataView = new DataView(buffer);
+	// Size prefix: count of bytes following the size field.
+	assert.strictEqual(dataView.getBigUint64(0, core.endian), BigInt(1 + 2 + 16));
+	// Payload type.
+	assert.strictEqual(dataView.getUint8(8), core.GeometryPayloadType.RemoveNodes);
+	assert.strictEqual(core.GeometryPayloadType.RemoveNodes, 13,
+		'RemoveNodes must keep the C++ enum value (after MaterialPointer=12)');
+	// Count and uids.
+	assert.strictEqual(dataView.getUint16(9, core.endian), 2);
+	assert.strictEqual(dataView.getBigUint64(11, core.endian), 5n);
+	assert.strictEqual(dataView.getBigUint64(19, core.endian), 7n);
+});
+
+test('encodeRemoveNodes handles a single uid', () => {
+	const buffer = new ArrayBuffer(8 + 1 + 2 + 8);
+	const size = encodeRemoveNodes([42n], buffer);
+	const dataView = new DataView(buffer);
+	assert.strictEqual(size, 19);
+	assert.strictEqual(dataView.getUint16(9, core.endian), 1);
+	assert.strictEqual(dataView.getBigUint64(11, core.endian), 42n);
+});
+
+function makeService(clientID) {
+	// Reset the static trackedResources map between tests so uids don't leak
+	// across cases (same pattern as test_geometry_service_send_gate.js).
+	GeometryService.trackedResources = new Map();
+	return new GeometryService(clientID);
+}
+
+test('UnstreamNode queues a removal for a node that was sent to the client', () => {
+	const clientID = 201;
+	const svc = makeService(clientID);
+	svc.StreamNode(9n);
+	// Simulate a successful send.
+	GeometryService.GetOrCreateTrackedResource(9n).Sent(clientID, 123n);
+
+	svc.UnstreamNode(9n);
+	assert.deepStrictEqual(svc.GetRemoveNodesToSend(), [9n]);
+	// Drained: a second call returns nothing.
+	assert.deepStrictEqual(svc.GetRemoveNodesToSend(), []);
+});
+
+test('UnstreamNode does not queue a removal for a node that was never sent', () => {
+	const svc = makeService(202);
+	svc.StreamNode(11n);
+	// Not sent (e.g. geometry channel never opened).
+	svc.UnstreamNode(11n);
+	assert.deepStrictEqual(svc.GetRemoveNodesToSend(), []);
+});
+
+test('UnstreamNode on a node the client never needed is a no-op', () => {
+	const svc = makeService(203);
+	GeometryService.GetOrCreateTrackedResource(13n).Sent(203, 1n);
+	// StreamNode was never called, so clientNeeds is false: nothing to do.
+	svc.UnstreamNode(13n);
+	assert.deepStrictEqual(svc.GetRemoveNodesToSend(), []);
+});
+
+test('UnstreamNode twice only queues one removal', () => {
+	const clientID = 204;
+	const svc = makeService(clientID);
+	svc.StreamNode(15n);
+	GeometryService.GetOrCreateTrackedResource(15n).Sent(clientID, 1n);
+	svc.UnstreamNode(15n);
+	svc.UnstreamNode(15n);
+	assert.deepStrictEqual(svc.GetRemoveNodesToSend(), [15n]);
+});