private async void TryConnectToController(string ipAddress, int port)
{
if (controllerClientSocket != null)
{
TextToaster.Toast("Cannot connect to multiple controllers at once.");
return;
}
++connectingCount;
var random = new System.Random();
int userId = random.Next();
IPAddress controllerIpAddress;
if (!IPAddress.TryParse(ipAddress, out controllerIpAddress))
{
TextToaster.Toast($"Failed to parse {ipAddress} as an IP address.");
--connectingCount;
return;
}
var controllerEndPoint = new IPEndPoint(controllerIpAddress, port);
var tcpSocket = new TcpSocket(new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp));
if (await tcpSocket.ConnectAsync(controllerEndPoint))
{
controllerClientSocket = new ControllerClientSocket(userId, tcpSocket);
}
--connectingCount;
}
void Update()
{
UpdateUI();
if (connectionWindow.Visibility)
{
if (Input.GetKeyDown(KeyCode.Return))
{
if (connectionWindow.ConnectionTarget == ConnectionTarget.Controller)
{
string ipAddressText = connectionWindow.IpAddress;
if (ipAddressText.Length == 0)
{
ipAddressText = "127.0.0.1";
}
TryConnectToController(ipAddressText, ControllerMessages.PORT);
}
else
{
string ipAddressText = connectionWindow.IpAddress;
if (ipAddressText.Length == 0)
{
ipAddressText = "127.0.0.1";
}
if (!IPAddress.TryParse(ipAddressText, out IPAddress ipAddress))
{
TextToaster.Toast($"Failed to parse {ipAddress} as an IP address.");
}
StartCoroutine(TryConnectToKinectSender(new IPEndPoint(ipAddress, SENDER_DEFAULT_PORT)));
}
}
}
// Sets the anchor's position and rotation using the current position of the HoloLens device.
if (Input.GetKeyDown(KeyCode.Space))
{
sharedSpaceScene.SetPositionAndRotation(mainCameraTransform.position, mainCameraTransform.rotation);
}
if (Input.GetKeyDown(KeyCode.V))
{
sharedSpaceScene.GizmoVisibility = !sharedSpaceScene.GizmoVisibility;
}
if (Input.GetKeyDown(KeyCode.F))
{
FpsCounter.Toast();
}
if (controllerClientSocket != null)
{
UpdateControllerClient();
}
UpdateReceivers();
}
private async void TryConnectToController(string ipAddress, int port)
{
if (controllerClientSocket != null)
{
TextToaster.Toast("Cannot connect to multiple controllers at once.");
return;
}
if (!IPAddress.TryParse(ipAddress, out IPAddress controllerIpAddress))
{
TextToaster.Toast($"Failed to parse {ipAddress} as an IP address.");
return;
}
Interlocked.Increment(ref connectingCount);
var controllerEndPoint = new IPEndPoint(controllerIpAddress, port);
var tcpSocket = new TcpSocket(new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp));
try
{
if (await tcpSocket.ConnectAsync(controllerEndPoint))
{
controllerClientSocket = new ControllerClientSocket(viewerId, tcpSocket);
}
}
catch (TcpSocketException e)
{
TextToaster.Toast($"Failed not connect to the controller: {e.Message}");
}
Interlocked.Decrement(ref connectingCount);
}
void Awake()
{
if (instance != null)
{
Debug.LogError("There should be only one TextToaster");
}
instance = this;
}
// Nudge a sender with a connect packet five times.
private IEnumerator TryConnectToKinectSender(IPEndPoint senderEndPoint)
{
Interlocked.Increment(ref connectingCount);
TextToaster.Toast($"Try Connecting to a Sender: {senderEndPoint}");
int receiverId = random.Next();
for (int i = 0; i < 5; ++i)
{
udpSocket.Send(PacketUtils.createConnectReceiverPacketBytes(receiverId, true, true).bytes, senderEndPoint);
yield return(new WaitForSeconds(0.3f));
}
Interlocked.Decrement(ref connectingCount);
}
private async void TryConnectToKinectSender(IPEndPoint endPoint)
{
++connectingCount;
TextToaster.Toast($"Try connecting to a Sender at {endPoint}...");
var random = new System.Random();
int receiverSessionId;
while (true)
{
receiverSessionId = random.Next();
if (kinectReceivers.FirstOrDefault(x => x.ReceiverSessionId == receiverSessionId) == null)
{
break;
}
}
var kinectReceiver = new KinectReceiver(receiverSessionId, endPoint);
kinectReceivers.Add(kinectReceiver);
// Nudge the sender until a confirm packet is received.
for (int i = 0; i < 5; ++i)
{
if (kinectReceiver.State != PrepareState.Unprepared)
{
--connectingCount;
return;
}
udpSocket.Send(PacketHelper.createConnectReceiverPacketBytes(receiverSessionId, true, true), endPoint);
print($"Sent connect packet #{i}");
await Task.Delay(300);
}
// Give up and forget about the connection if a confirm packet has not been received after all the connect packets.
if (kinectReceiver.State == PrepareState.Unprepared)
{
kinectReceivers.Remove(kinectReceiver);
}
--connectingCount;
}
void Update()
{
float time = Time.time;
var timeStamps = new List <float>();
foreach (var t in this.timeStamps)
{
if ((time - t) < timeInterval)
{
timeStamps.Add(t);
}
}
timeStamps.Add(time);
this.timeStamps = timeStamps;
if (Input.GetKeyDown(KeyCode.F))
{
TextToaster.Toast($"FPS: {this.timeStamps.Count / timeInterval}");
}
}
private void UpdateControllerClient()
{
ViewerScene viewerScene = null;
try
{
viewerScene = controllerClientSocket.ReceiveViewerScene();
}
catch (TcpSocketException e)
{
print($"TcpSocketException while receiving: {e}");
controllerClientSocket = null;
return;
}
if (viewerScene != null)
{
foreach (var kinectSenderElement in viewerScene.kinectSenderElements)
{
IPAddress ipAddress;
if (!IPAddress.TryParse(kinectSenderElement.address, out ipAddress))
{
TextToaster.Toast($"Failed to parse {ipAddress} as an IP address.");
}
var endPoint = new IPEndPoint(ipAddress, kinectSenderElement.port);
if (kinectReceivers.FirstOrDefault(x => x.SenderEndPoint == endPoint) != null)
{
continue;
}
TryConnectToKinectSender(endPoint);
}
foreach (var kinectReceiver in kinectReceivers)
{
var kinectSenderElement = viewerScene.kinectSenderElements.FirstOrDefault(x => x.address == kinectReceiver.SenderEndPoint.Address.ToString() &&
x.port == kinectReceiver.SenderEndPoint.Port);
if (kinectSenderElement != null)
{
var kinectOrigin = kinectReceiver.KinectOrigin;
if (kinectOrigin != null)
{
kinectOrigin.transform.localPosition = kinectSenderElement.position;
kinectOrigin.transform.localRotation = kinectSenderElement.rotation;
}
}
}
this.viewerScene = viewerScene;
}
var receiverStates = new List <ReceiverState>();
foreach (var receiver in kinectReceivers)
{
var receiverState = new ReceiverState(receiver.SenderEndPoint.Address.ToString(),
receiver.SenderEndPoint.Port,
receiver.ReceiverSessionId);
receiverStates.Add(receiverState);
}
try
{
controllerClientSocket.SendViewerState(receiverStates);
}
catch (TcpSocketException e)
{
print($"TcpSocketException while connecting: {e}");
controllerClientSocket = null;
}
}
private void UpdateReceivers()
{
var confirmPacketInfos = new List <ConfirmPacketInfo>();
var senderPacketInfos = new Dictionary <int, SenderPacketInfo>();
try
{
SenderPacketClassifier.Classify(udpSocket, receivers.Values, confirmPacketInfos, senderPacketInfos);
}
catch (UdpSocketException e)
{
TextToaster.Toast($"Error from SenderPacketClassifier.Classify(): {e.Message}");
}
foreach (var confirmPacketInfo in confirmPacketInfos)
{
int receiverId = confirmPacketInfo.ConfirmPacket.receiverId;
print($"confirmPacketInfo - 1: receiver: {receiverId}");
// Ignore if there is already a receiver with the receiver ID.
if (receivers.ContainsKey(receiverId))
{
continue;
}
print($"confirmPacketInfo - 2: receiver: {receiverId}, sender: {confirmPacketInfo.ConfirmPacket.senderId}");
// Receiver and KinectOrigin gets created together.
// When destroying any of them, the other of the pair should also be destroyed.
var receiver = new Receiver(receiverId, confirmPacketInfo.ConfirmPacket.senderId, confirmPacketInfo.SenderEndPoint);
receivers.Add(confirmPacketInfo.ConfirmPacket.receiverId, receiver);
var kinectOrigin = sharedSpaceScene.AddKinectNode(receiverId);
// Apply transformation of kinectSenderElement if there is a corresponding one.
if (controllerScene != null)
{
var controllerNode = controllerScene.FindNode(receiver.SenderEndPoint);
if (controllerNode != null)
{
kinectOrigin.transform.localPosition = controllerNode.position;
kinectOrigin.transform.localRotation = controllerNode.rotation;
}
}
}
// Send heartbeat packets to senders.
foreach (var receiver in receivers.Values)
{
receiver.SendHeartBeat(udpSocket);
}
// Using a copy of remoteSenders through ToList() as this allows removal of elements from remoteSenders.
foreach (var senderPacketInfoPair in senderPacketInfos)
{
// The keys of senderPacketInfos are sender IDs, not receiver IDs like other collections.
int senderId = senderPacketInfoPair.Key;
// Since senderPacketInfos were built based on receivers, there should be a corresponding receiver.
var receiver = receivers.Values.First(x => x.SenderId == senderId);
var kinectNode = sharedSpaceScene.GetKinectNode(receiver.ReceiverId);
receiver.ReceivePackets(udpSocket, senderPacketInfoPair.Value, kinectNode.KinectRenderer.Material, kinectNode.Speaker.RingBuffer);
// Remove receivers that did not receive any packet for too long.
if (receiver.IsTimedOut())
{
TextToaster.Toast($"Receiver {receiver.ReceiverId} timed out.");
receivers.Remove(receiver.ReceiverId);
sharedSpaceScene.RemoveKinectNode(receiver.ReceiverId);
continue;
}
if (kinectNode.KinectRenderer.State == PrepareState.Unprepared)
{
if (receiver.VideoMessages.Count > 0)
{
foreach (var videoMessage in receiver.VideoMessages.Values)
{
CoroutineRunner.RunWithTotalTimeOut(kinectNode.KinectRenderer.Prepare(videoMessage));
break;
}
}
}
else if (kinectNode.KinectRenderer.State == PrepareState.Preparing)
{
kinectNode.SetProgressText(receiver.SenderEndPoint, kinectNode.kinectRenderer.Progress);
kinectNode.ProgressTextVisibility = true;
}
else if (kinectNode.KinectRenderer.State == PrepareState.Prepared)
{
kinectNode.ProgressTextVisibility = false;
}
var floorVideoMessage = receiver.VideoMessages.Values.FirstOrDefault(x => x.floor != null);
if (floorVideoMessage != null)
{
kinectNode.UpdateFrame(floorVideoMessage.floor);
}
receiver.UpdateFrame(udpSocket);
}
}
private void UpdateControllerClient()
{
ControllerScene controllerScene = null;
try
{
controllerScene = controllerClientSocket.ReceiveControllerScene();
}
catch (TcpSocketException e)
{
print($"TcpSocketException while receiving from controller: {e}");
controllerClientSocket = null;
return;
}
if (controllerScene != null)
{
foreach (var controllerNode in controllerScene.nodes)
{
if (!IPAddress.TryParse(controllerNode.senderAddress, out IPAddress ipAddress))
{
TextToaster.Toast($"Failed to parse an IP address ({ipAddress}) from controller.");
continue;
}
var senderEndPoint = new IPEndPoint(ipAddress, controllerNode.senderPort);
if (receivers.Values.FirstOrDefault(x => x.SenderEndPoint.Equals(senderEndPoint)) != null)
{
continue;
}
StartCoroutine(TryConnectToKinectSender(senderEndPoint));
}
foreach (var receiverPair in receivers)
{
var controllerNode = controllerScene.FindNode(receiverPair.Value.SenderEndPoint);
if (controllerNode != null)
{
var kinectNode = sharedSpaceScene.GetKinectNode(receiverPair.Key);
if (kinectNode != null)
{
kinectNode.transform.localPosition = controllerNode.position;
kinectNode.transform.localRotation = controllerNode.rotation;
}
}
}
this.controllerScene = controllerScene;
}
var receiverStates = new List <ReceiverState>();
foreach (var receiver in receivers.Values)
{
var receiverState = new ReceiverState(receiver.ReceiverId, receiver.SenderId, receiver.SenderEndPoint);
receiverStates.Add(receiverState);
}
try
{
controllerClientSocket.SendViewerState(receiverStates);
}
catch (TcpSocketException e)
{
print($"TcpSocketException while connecting: {e}");
controllerClientSocket = null;
}
}
public static void Toast()
{
TextToaster.Toast($"FPS: {instance.timeStamps.Count / instance.timeInterval}");
}
