teleportxr 1.0.8 → 1.0.10

package/client/client.js

@@ -111,6 +111,7 @@ class Client {
     Start()
     {
         this.setupCommand=new command.SetupCommand();
+		this.setupCommand.float32_draw_distance=10.0;
 		if(this.scene)
 		{
 			if(this.scene.backgroundTexturePath&&this.scene.backgroundTexturePath!="")
@@ -130,7 +131,7 @@ class Client {
     {
 		this.webRtcConnectionManager=WebRtcConnectionManager.getInstance();
         // We make sure WebRTC has a connection for this client.
-  		this.webRtcConnection = this. webRtcConnectionManager.createConnection(
+  		this.webRtcConnection = this.webRtcConnectionManager.createConnection(
 										this.clientID
 										,this.streamingConnectionStateChanged.bind(this)
 										,this.receivedMessageReliable.bind(this)

package/client/client_manager.js

@@ -47,7 +47,7 @@ class ClientManager
 				error("Failed to create a root node for client "+clientID);
 				return null;
 			}
-			var sigCli=signaling.signalingClients[clientID];
+			var sigCli=signaling.signalingClients.get(clientID);
 			var sigSend=sigCli.sendToClient.bind(sigCli);
 			var c=new client.Client(clientID,sigSend);
 			c.setOrigin(origin_uid);
@@ -97,7 +97,7 @@ class ClientManager
 	writeState() {
 		var content="<table><tr><th>Client Id</th><th>IP Address</th><th>Signalling State</th></tr>";
 		for (let [cl_id,cl] of this.clients) {
-			var sigCli=signaling.signalingClients[cl_id];
+			var sigCli=signaling.signalingClients.get(cl_id);
 			content+="\n<tr><td>"+cl_id+"</td> <td>" + sigCli.ip + "</td> <td>" + sigCli.signalingState + "</td></tr>";
 		};
 		content+="\n</table>";

package/client/geometry_service.js

@@ -27,30 +27,30 @@ class TrackedResource
         this.acknowledged=new bit.BitSet();	        // Whether the client acknowledged receiving the resource.		
     }
 	IsNeededByClient(clientID) {
-		return this.clientNeeds.get[clientIDToIndex[clientID]];
+		return this.clientNeeds.get(clientIDToIndex.get(clientID));
 	}
 	WasSentToClient(clientID) {
-		return this.sent.get[clientIDToIndex[clientID]];
+		return this.sent.get(clientIDToIndex.get(clientID));
 	}
 	WasAcknowledgedByClient(clientID) {
-		return this.acknowledged.get(clientIDToIndex[clientID]);
+		return this.acknowledged.get(clientIDToIndex.get(clientID));
 	}
 	GetTimeSent(clientID) {
-		return this.sent_server_time_us[clientID];
+		return this.sent_server_time_us.get(clientID);
 	}
 	Sent(clientID,timestamp) {
-		this.sent.set(clientIDToIndex[clientID],true);
-		this.acknowledged.set(clientIDToIndex[clientID],false);
+		this.sent.set(clientIDToIndex.get(clientID),true);
+		this.acknowledged.set(clientIDToIndex.get(clientID),false);
 		this.sent_server_time_us.set(clientID,timestamp);
 	}
 	AcknowledgeBy(clientID) {
-		this.acknowledged.set(clientIDToIndex[clientID],true);
+		this.acknowledged.set(clientIDToIndex.get(clientID),true);
 		// erase timestamp?
 		this.sent_server_time_us.delete(clientID);
 	}
 	Timeout(clientID) {
-		this.sent.set(clientIDToIndex[clientID],false);
-		this.acknowledged.set(clientIDToIndex[clientID],false);
+		this.sent.set(clientIDToIndex.get(clientID),false);
+		this.acknowledged.set(clientIDToIndex.get(clientID),false);
 		this.sent_server_time_us.clear(clientID);
 	}
 };
@@ -92,6 +92,8 @@ class GeometryService
 		this.streamedFontAtlases=new Map();
 
 		this.backgroundTextureUid=0;
+		// ten seconds for timeout. Tweak this.
+		this.timeout_us=10000000;
     }
 	SetScene(sc) {
 		this.scene=sc;
@@ -299,8 +301,6 @@ class GeometryService
 
 	UpdateNodesToStream()
 	{
-		// ten seconds for timeout. Tweak this.
-		const timeout_us=10000000;
 		//  The set of ALL the nodes of sufficient priority that the client NEEDS is streamedNodes.
 		for(let uid of this.nodesToStreamEventually)
 		{
@@ -343,7 +343,7 @@ class GeometryService
 			{
 				var timeSentUs=res.GetTimeSent(this.clientID);
 				// If we sent it too long ago with no acknowledgement, we can send it again.
-				if(time_now_us-timeSentUs>timeout_us)
+				if(time_now_us-timeSentUs>this.timeout_us)
 				{
 					res.Timeout(this.clientID);
 				}
@@ -376,15 +376,17 @@ class GeometryService
 		var resource_uids=[];
 		let time_now_us=core.getTimestampUs();
 		for(const [uid, count] of this.streamedMeshes)
-		 {
+		{
 			//is mesh streamed
 			var res=GeometryService.GetOrCreateTrackedResource(uid);
-			res.Sent(this.clientID,time_now_us);
+			// If it was already received we don't send it:
+			if(res.WasAcknowledgedByClient(this.clientID))
+				continue;
 			if(res.WasSentToClient(this.clientID))
 			{
 				var timeSentUs=res.GetTimeSent(this.clientID);
 				// If we sent it too long ago with no acknowledgement, we can send it again.
-				if(time_now_us-timeSentUs>timeout_us)
+				if(time_now_us-timeSentUs>this.timeout_us)
 				{
 					res.Timeout(this.clientID);
 				}
@@ -393,6 +395,7 @@ class GeometryService
 			{
 				// if it hasn't been sent at all to our client, we add its resources.
 				resource_uids.push(uid);
+				res.Sent(this.clientID,time_now_us);
 			}
 		};
 		return resource_uids;

package/connections/webrtcconnection.js

@@ -6,7 +6,7 @@ const DefaultRTCPeerConnection = require('@roamhq/wrtc').RTCPeerConnection;
 
 const TIME_TO_CONNECTED = 10000;
 const TIME_TO_HOST_CANDIDATES = 3000;  // NOTE: Too long.
-const TIME_TO_RECONNECTED = 10000;
+const TIME_TO_RECONNECTED = 1000;
 
 function EVEN_ID(id) {
     return (id-(id%2))
@@ -22,7 +22,7 @@ class WebRtcConnection extends EventEmitter
 		this.id = id;
 		this.state = 'open';
 
-		options = {
+		this.options = {
 			RTCPeerConnection: DefaultRTCPeerConnection,
 			clearTimeout,
 			setTimeout,
@@ -38,75 +38,110 @@ class WebRtcConnection extends EventEmitter
 			timeToReconnected
 		} = options;
 
-		this.connectionStateChanged	=options.connectionStateChanged;
+		this.connectionStateChanged			=options.connectionStateChanged;
 		this.messageReceivedReliableCb		=options.messageReceivedReliable;
 		this.messageReceivedUnreliableCb	=options.messageReceivedUnreliable;
 		
 		this.sendConfigMessage		=options.sendConfigMessage;
-		const peerConnection		=new RTCPeerConnection({ sdpSemantics: 'unified-plan'});
-        this.pc						=peerConnection;
+
+
+		Object.defineProperties(this, {
+			iceConnectionState: {
+				get ()
+				{
+					return this.peerConnection.iceConnectionState;
+				}
+			},
+			localDescription: {
+				get ()
+				{
+					return descriptionToJSON(this.peerConnection.localDescription, true);
+				}
+			},
+			remoteDescription: {
+				get ()
+				{
+					return descriptionToJSON(this.peerConnection.remoteDescription);
+				}
+			},
+			signalingState: {
+				get ()
+				{
+					return this.peerConnection.signalingState;
+				}
+			}
+		});
+		this.reconnect();
+	}
+
+	reconnect()
+	{
+		this.peerConnection		=new DefaultRTCPeerConnection({ sdpSemantics: 'unified-plan'});
         
-		this.beforeOffer(peerConnection);
+		this.beforeOffer();
  
-		let connectionTimer = options.setTimeout(() =>
+		let connectionTimer = this.options.setTimeout(() =>
 		{
-			if (peerConnection.iceConnectionState !== 'connected'
-				&& peerConnection.iceConnectionState !== 'completed')
+			if (this.peerConnection.iceConnectionState !== 'connected'
+				&& this.peerConnection.iceConnectionState !== 'completed')
 			{
 				this.close();
 			}
-		}, timeToConnected);
+		}, this.options.timeToConnected);
 
 		let reconnectionTimer = null;
 
 		const onIceConnectionStateChange = () =>
 		{
-            console.log("ICE state changed to: "+peerConnection.iceConnectionState);
-			if (peerConnection.iceConnectionState === 'connected'
-				|| peerConnection.iceConnectionState === 'completed')
+            console.log("ICE state changed to: "+this.peerConnection.iceConnectionState);
+			if (this.peerConnection.iceConnectionState === 'connected'
+				|| this.peerConnection.iceConnectionState === 'completed')
 			{
 				if (connectionTimer)
 				{
-					options.clearTimeout(connectionTimer);
+					this.options.clearTimeout(connectionTimer);
 					connectionTimer = null;
 				}
-				options.clearTimeout(reconnectionTimer);
+				this.options.clearTimeout(reconnectionTimer);
 				reconnectionTimer = null;
-			} else if (peerConnection.iceConnectionState === 'disconnected'
-				|| peerConnection.iceConnectionState === 'failed')
+			} else if (this.peerConnection.iceConnectionState === 'disconnected'
+				|| this.peerConnection.iceConnectionState === 'failed')
 			{
+				this.peerConnection.restartIce();
+				console.log("restartIce()");
 				if (!connectionTimer && !reconnectionTimer)
 				{
 					const self = this;
-					reconnectionTimer = options.setTimeout(() =>
+					reconnectionTimer = this.options.setTimeout(() =>
 					{
-						self.close();
-					}, timeToReconnected);
+						this.reconnect();
+						this.doOffer();
+					}, this.options.timeToReconnected);
 				}
 			}
 		};
 		const onIceGatheringStateChange = () =>
 		{
-            console.log("ICE gathering state changed to: "+peerConnection.iceGatheringState);
+            console.log("ICE gathering state changed to: "+this.peerConnection.iceGatheringState);
         };
 
-		peerConnection.addEventListener('iceconnectionstatechange', onIceConnectionStateChange);
-		peerConnection.addEventListener('icegatheringstatechange', onIceGatheringStateChange);
+		this.peerConnection.addEventListener('iceconnectionstatechange', onIceConnectionStateChange);
+		this.peerConnection.addEventListener('icegatheringstatechange', onIceGatheringStateChange);
 
         
 		const onConnectionStateChange = () =>
-           {
-            console.log("Connection State changed to: "+peerConnection.connectionState.toString());
-            this.connectionStateChanged(this,peerConnection.connectionState);
+        {
+            console.log("Connection State changed to: "+this.peerConnection.connectionState.toString());
+            this.connectionStateChanged(this,this.peerConnection.connectionState);
         }
-        peerConnection.addEventListener("connectionstatechange", onConnectionStateChange);
+        this.peerConnection.addEventListener("connectionstatechange", onConnectionStateChange);
 
         this.onIceCandidate= ({ candidate })=>
         {
             if (!candidate)
             {
-                options.clearTimeout(this.timeout);
-                //peerConnection.removeEventListener('icecandidate', this.onIceCandidate);
+                this.options.clearTimeout(this.timeout);
+                //this.peerConnection.removeEventListener('icecandidate', this.onIceCandidate);
                 this.deferred.resolve();
                 return;
             }
@@ -138,7 +173,6 @@ class WebRtcConnection extends EventEmitter
                 this.deferred.reject(new Error('Timed out waiting for host candidates'));
             }, timeToHostCandidates);
         
-        
             peerConnection.addEventListener('icecandidate', this.onIceCandidate);
         
             await this.deferred.promise;
@@ -148,11 +182,11 @@ class WebRtcConnection extends EventEmitter
 		{
 			try
 			{ 
-				const offer = await peerConnection.createOffer();
-				await peerConnection.setLocalDescription(offer);
+				const offer = await this.peerConnection.createOffer();
+				await this.peerConnection.setLocalDescription(offer);
 				var message = '{"teleport-signal-type":"offer","sdp":"'+offer.sdp+'"}'; //
 				this.sendConfigMessage(this.id,message);
-				await this.waitUntilIceGatheringStateComplete(peerConnection, options);
+				await this.waitUntilIceGatheringStateComplete(this.peerConnection, this.options);
 			} catch (error)
 			{
                 console.error(error.toString());
@@ -174,32 +208,31 @@ class WebRtcConnection extends EventEmitter
             var sessionDescription=new wrtc.RTCSessionDescription();
             sessionDescription.sdp=answer;
             sessionDescription.type="answer";
-			await peerConnection.setRemoteDescription( sessionDescription);
+			await this.peerConnection.setRemoteDescription( sessionDescription);
 		};
 		this.applyRemoteCandidate = async(candidate_txt,mid,mlineindex)=>
 		{
             console.log("received remote candidate.");
-            peerConnection.addIceCandidate(new wrtc.RTCIceCandidate({
+            this.peerConnection.addIceCandidate(new wrtc.RTCIceCandidate({
               candidate: candidate_txt,
               sdpMLineIndex: mlineindex,
               sdpMid: mid
             }));
 		};
-
 		this.close = () =>
 		{
-			peerConnection.removeEventListener('iceconnectionstatechange', onIceConnectionStateChange);
+			this.peerConnection.removeEventListener('iceconnectionstatechange', onIceConnectionStateChange);
 			if (connectionTimer)
 			{
-				options.clearTimeout(connectionTimer);
+				this.options.clearTimeout(connectionTimer);
 				connectionTimer = null;
 			}
 			if (reconnectionTimer)
 			{
-				options.clearTimeout(reconnectionTimer);
+				this.options.clearTimeout(reconnectionTimer);
 				reconnectionTimer = null;
 			}
-			peerConnection.close();
+			this.peerConnection.close();
 			this.state = 'closed';
 			this.emit('closed');
 		};
@@ -215,33 +248,6 @@ class WebRtcConnection extends EventEmitter
 				signalingState: this.signalingState
 			};
 		};
-
-		Object.defineProperties(this, {
-			iceConnectionState: {
-				get ()
-				{
-					return peerConnection.iceConnectionState;
-				}
-			},
-			localDescription: {
-				get ()
-				{
-					return descriptionToJSON(peerConnection.localDescription, true);
-				}
-			},
-			remoteDescription: {
-				get ()
-				{
-					return descriptionToJSON(peerConnection.remoteDescription);
-				}
-			},
-			signalingState: {
-				get ()
-				{
-					return peerConnection.signalingState;
-				}
-			}
-		});
 	}
     sendGeometry(buffer) {
 		try {	
@@ -251,7 +257,7 @@ class WebRtcConnection extends EventEmitter
             console.error('datachannel.sendGeometry exception: '+exception.message);
 		}
     }
-    beforeOffer(peerConnection) {
+    beforeOffer() {
           
         this.videoDataChannel = this.createDataChannel("video",20);
         this.tagDataChannel = this.createDataChannel("video_tags",40);
@@ -259,7 +265,7 @@ class WebRtcConnection extends EventEmitter
         this.geometryDataChannel = this.createDataChannel("geometry_unframed",80);
         this.reliableDataChannel = this.createDataChannel("reliable",100);
         this.unreliableDataChannel = this.createDataChannel("unreliable",120,false);
-       // this.dataChannel = peerConnection.createDataChannel('ping-pong',{id:2050});
+       // this.dataChannel = this.peerConnection.createDataChannel('ping-pong',{id:2050});
       
         function onMessage({ data }) {
           if (data === 'ping') {
@@ -270,9 +276,9 @@ class WebRtcConnection extends EventEmitter
         // NOTE(mroberts): This is a hack so that we can get a callback when the
         // RTCPeerConnection is closed. In the future, we can subscribe to
         // "connectionstatechange" events.
-        const { close } = peerConnection;
+        const { close } = this.peerConnection;
         var self=this;
-        peerConnection.close = function() {
+        this.peerConnection.close = function() {
             //self.dataChannel.removeEventListener('message', onMessage);
           return close.apply(this, arguments);
         };
@@ -304,7 +310,7 @@ class WebRtcConnection extends EventEmitter
         //See https://web.dev/articles/webrtc-datachannels. Can only use id if negotiated=true.
         const dataChannelOptions={ordered:reliable,maxRetransmits:reliable?10000:0,id:id};
         
-        var dc=this.pc.createDataChannel(label,dataChannelOptions);
+        var dc=this.peerConnection.createDataChannel(label,dataChannelOptions);
        
          dc.onmessage = this.receiveMessage.bind(this,id);
   

package/package.json

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

package/scene/scene.js

@@ -60,6 +60,7 @@ class Scene {
 				if (pose) {
 					n.pose.position = { x: pose.position[0], y: pose.position[1], z: pose.position[2] };
 					n.pose.orientation = { x: pose.orientation[0], y: pose.orientation[1], z: pose.orientation[2], w: pose.orientation[3] };
+					n.pose.scale = { x: pose.scale[0], y: pose.scale[1], z: pose.scale[2] };
 				}
 				const components = sub_obj["components"];
 				if (components) {

package/signaling.js

@@ -60,7 +60,7 @@ function sendResponseToClient(clientID) {
 	if (!signalingClients.has(clientID)) {
         console.log("No client "+clientID+" found.");
 	} else {
-        var signalingClient=signalingClients[clientID];
+        var signalingClient=signalingClients.get(clientID);
 		// First, we send the WebSockets signaling response.
 		var txt =
 			'{"teleport-signal-type":"request-response","content":{"clientID": ' +
@@ -96,7 +96,7 @@ function processInitialRequest(clientID, signalingClient, content) {
 		}
 		// identifies as a previous client. Discard the new client ID.
 		//TODO: we're taking the client's word for it that it is clientID. Some kind of token/hash?
-		signalingClients[clientID] = signalingClient;
+		signalingClients.set(clientID,signalingClient);
 		if (j_clientID != clientID) {
 			console.log(
 				"info: Remapped from " + clientID + " to " + j_clientID
@@ -106,36 +106,39 @@ function processInitialRequest(clientID, signalingClient, content) {
 			);
 
 			if (signalingClients.has(clientID)) {
-				signalingClients[clientID] = null;
+				signalingClients.delete(clientID);
 				clientUids.erase(clientID);
 			}
 			clientID = j_clientID;
 		}
 	}
 	var ipAddr = signalingClient.ip_addr_port;
+	if (desiredIP.length != 0 && !ipAddr.contains(desiredIP))
+		return;
 	// Skip clients we have already added.
 	if (signalingClient.signalingState == SignalingState.START)
 		signalingClient.ChangeSignalingState(SignalingState.REQUESTED);
+	//Ignore connections from clients with the wrong IP, if a desired IP has been set.
 	// if signalingState is START, we should not have a client...
-	if (signalingClient.client != null) {
+	if (signalingClient.signalingState==SignalingState.ACCEPTED||signalingClient.signalingState==SignalingState.STREAMING)
+	{
 		// ok, we've received a connection request from a client that WE think we already have.
 		// Apparently the CLIENT thinks they've disconnected.
 		// The client might, as far as we know, have lost the information it needs to continue the connection.
 		// Therefore we should resend everything required.
-		signalingClient.ChangeSignalingState(SignalingState.STREAMING);
+		//signalingClient.ChangeSignalingState(SignalingState.STREAMING);
 		console.log(
 			"Warning: Client " +
 				clientID +
 				" reconnected, but we didn't know we'd lost them."
 		);
 		// It may be just that the connection request was already in flight when we accepted its predecessor.
-		sendResponseToClient(clientID);
+		//sendResponseToClient(clientID);
+		startStreaming(signalingClient);
 		return;
 	}
-	if (signalingClient.signalingState != SignalingState.REQUESTED)
-        return;
-	//Ignore connections from clients with the wrong IP, if a desired IP has been set.
-	if (desiredIP.length == 0 || ipAddr.contains(desiredIP)) {
+	if (signalingClient.signalingState==SignalingState.REQUESTED)
+	{
 		startStreaming(signalingClient);
 	}
 }
@@ -252,7 +255,7 @@ exports.sendConfigMessage = function (clientID, msg) {
 
 	if (signalingClients.has(clientID)) {
 		console.log("sendConfigMessage to "+clientID+": "+msg);
-		signalingClients[clientID].ws.send(escapedStr);
+		signalingClients.get(clientID).ws.send(escapedStr);
 	} else {
 		console.log(
 			"sendConfigMessage with clientID " +

package/server.js

@@ -1,35 +0,0 @@
-'use strict';
- 
-const WebRtcConnectionManager = require('./connections/webrtcconnectionmanager');
-const cm = require('./client/client_manager.js');
-
-const signaling=require("./signaling.js");
-const scene=require("./scene/scene.js");
-
-var sc=new scene.Scene();
-
-const fs = require('fs');
-const path = require('path');
-
-const assetsPath = path.join(__dirname,'assets');
-
-sc.Load(path.join(assetsPath,'scene.json'));
-
-// This is our app's callback for when a new client is to be created.
-// It must return the origin uid for the client.
-function createNewClient(clientID) {
-	var origin_uid=sc.CreateNode();
-	return origin_uid;
-}
-
-// This will be called AFTER a client has been created, so we can access it from the clientManager.
-function onClientPostCreate(clientID) {
-	var client=cm.getInstance().GetClient(clientID);
-	client.SetScene(sc);
-}
-
-const webRtcConnectionManager = WebRtcConnectionManager.getInstance();
-webRtcConnectionManager.SetSendConfigMessage(signaling.sendConfigMessage);
-cm.getInstance().SetNewClientCallback(createNewClient);
-cm.getInstance().SetClientPostCreationCallback(onClientPostCreate);
-signaling.init(webRtcConnectionManager,cm.getInstance().newClient.bind(cm.getInstance()));