public void RunServer(string serverName, int?port)
        {
            lock (_connectionLock)
            {
                if (_connection == null)
                {
                    if (port.HasValue)
                    {
                        _connection = Vrpn.Connection.CreateServerConnection(port.Value);
                    }
                    else
                    {
                        _connection = Vrpn.Connection.CreateServerConnection();
                    }
                    _connectionCounter = 0;
                }
                _connectionCounter++;

                _server = new Vrpn.TrackerServer(serverName, _connection, 1);
            }

            FireConnectionChanged();

            _serverLoopTask = Task.Run(() => ServerLoop());
        }
        private async Task ServerLoop()
        {
            int counter = 0;

            Random rnd = new Random();

            while (!_requestStopServer)
            {
                await Task.Delay(10);

                lock (_connectionLock)
                {
                    _connection.Update();
                }

                Vector3 pos;
                if (BroadcastPosition.HasValue && BroadcastPosition_Noise.HasValue)
                {
                    double period = 3;
                    var    val    = Math.Sin((double)DateTime.Now.Ticks / TimeSpan.TicksPerSecond / period * Math.PI * 2);
                    pos = BroadcastPosition.Value + BroadcastPosition_Noise.Value * val;
                }
                else if (BroadcastPosition.HasValue)
                {
                    pos = BroadcastPosition.Value;
                }
                else
                {
                    pos = new Vector3(counter, rnd.NextDouble(), DateTime.Now.Second);
                }
                _server.ReportPose(0, DateTime.Now, pos.ToVrpn(), new Vrpn.Quaternion());
                counter++;
                _server.Update();
            }
            _requestStopServer = false;
            _server.Dispose();
            _server = null;

            lock (_connectionLock)
            {
                _connectionCounter--;

                if (_connectionCounter <= 0)
                {
                    _connection.Dispose();
                    _connection = null;
                }
            }
        }