public static void RunServer()
{
using (NetMQSocket serverSocket = new ResponseSocket())
{
serverSocket.Bind("tcp://127.0.0.1:5555");
while (true)
{
string message1 = serverSocket.ReceiveFrameString();
Console.WriteLine("Receive message :\r\n{0}\r\n", message1);
string[] msg = message1.Split(':');
string message = msg[1];
#region 根据接收到的消息，返回不同的信息
if (message == "Hello")
{
serverSocket.SendFrame("World");
}
else
{
serverSocket.SendFrame(message);
}
#endregion
if (message == "exit")
{
break;
}
}
}
}
public void RequestReply()
{
ThreadPool.QueueUserWorkItem(state =>
{
var server = new ResponseSocket();
server.Bind("tcp://*:5555");
while (!_stopLoops)
{
try
{
var receiveFrame = server.ReceiveFrameBytes();
var request = Serializer.Deserialize <Request>(new MemoryStream(receiveFrame));
var response = OnRequest(request);
using (var responseStream = new MemoryStream())
{
Serializer.Serialize(responseStream, response);
server.SendFrame(responseStream.ToArray());
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
});
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
using var server = new ResponseSocket("tcp://*:8050");
while (!stoppingToken.IsCancellationRequested)
{
string serverMessage = "";
await Task.Run(() =>
{
try
{
serverMessage = server.ReceiveFrameString();
Console.WriteLine($"Client Sent: {serverMessage} DateTime: {DateTime.Now}");
Console.WriteLine("Sending reply to the client ...");
const string msg1 = "Hi", msg2 = "How are you ?";
var response = new NetMQMessage();
response.Append(msg1);
response.Append(msg2);
server.SendMultipartMessage(response);
Console.WriteLine($"Response has been sent => 1: {msg1}, 2: {msg2}");
_hubContext.Clients.All.SendAsync("ReceiveNotification", serverMessage);
}
catch (Exception ex)
{
Console.WriteLine($"Error: {ex.Message} DateTime: {DateTime.Now}");
}
});
}
}
static void Main(string[] args)
{
string connectionString = args[0];
using (var send = new PushSocket(">tcp://127.0.0.1:9999"))
using (var receive = new ResponseSocket(connectionString))
{
while (true)
{
// Block for request
var message = receive.ReceiveFrameString();
var msgId = Guid.NewGuid().ToString();
// Acknowledge
receive.SendFrame("200, ACK");
// Do Work ...
Thread.Sleep(2000);
// Send response
send.SendFrame(string.Format("Handler {0} completed task {1}",
connectionString, msgId));
// Exit handler
break;
}
}
}
private void EventLoop()
{
var addr = context.ConnectionInfo.HeartbeatZmqAddress;
this.logger.LogDebug("Starting heartbeat server at {Address}.", addr);
socket = new ResponseSocket();
socket.Bind(addr);
while (alive)
{
// We use the Bytes receiver so that we can ping back data
// unmodified, without worrying about encodings.
try
{
var data = socket.ReceiveFrameBytes();
logger.LogDebug($"Got heartbeat message of length {data.Length}.");
if (!socket.TrySendFrame(data))
{
logger.LogError("Error sending heartbeat message back to client.");
}
}
catch (ThreadInterruptedException)
{
continue;
}
catch (Exception ex)
{
logger.LogCritical(ex, "Unhandled exception in heartbeat loop.");
}
}
}
public void RunPipeline(PairSocket shim)
{
publisherSocket = context.CreatePublisherSocket();
publisherSocket.Bind("tcp://*:" + StreamingProtocol.Port);
snapshotSocket = context.CreateResponseSocket();
snapshotSocket.Bind("tcp://*:" + SnapshotProtocol.Port);
snapshotSocket.ReceiveReady += OnSnapshotReady;
shim.ReceiveReady += OnShimReady;
heartbeatTimer = new NetMQTimer(StreamingProtocol.HeartbeatInterval);
heartbeatTimer.Elapsed += OnHeartbeatTimerElapsed;
shim.SignalOK();
poller = new Poller();
poller.AddSocket(shim);
poller.AddSocket(snapshotSocket);
poller.AddTimer(heartbeatTimer);
poller.Start();
publisherSocket.Dispose();
snapshotSocket.Dispose();
}
static void Main(string[] args)
{
int port = 5555;
if (args.Length > 1)
{
int.TryParse(args[0], out port);
}
Console.WriteLine($"Starting NetMQ at TCP port {port}.");
Console.WriteLine("Press CTRL+C to stop the service.");
try
{
using (var server = new ResponseSocket())
{
server.Bind($"tcp://*:{port}");
while (true)
{
var message = server.ReceiveFrameString();
Console.WriteLine(message);
Thread.Sleep(100);
server.SendFrame("***Processed***");
}
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
Console.WriteLine("An unexpected error occurred.");
}
}
public void SendAndReceive()
{
using (var front = new RouterSocket())
using (var back = new DealerSocket())
{
front.Bind("inproc://frontend");
back.Bind("inproc://backend");
var proxy = new Proxy(front, back);
Task.Factory.StartNew(proxy.Start);
using (var client = new RequestSocket())
using (var server = new ResponseSocket())
{
client.Connect("inproc://frontend");
server.Connect("inproc://backend");
client.SendFrame("hello");
Assert.AreEqual("hello", server.ReceiveFrameString());
server.SendFrame("reply");
Assert.AreEqual("reply", client.ReceiveFrameString());
}
proxy.Stop();
}
}
static void Main(string[] args)
{
using (var server = new ResponseSocket())
{
server.Bind("tcp://*:5555");
Console.WriteLine("The application have initialised");
var message = server.ReceiveMultipartMessage();
var messagePartOne = message[0].ConvertToString();
if ("FILE".Equals(messagePartOne))
{
var fileName = message[1].ConvertToString();
var data = message[2].ToByteArray();
Console.WriteLine("Frame 0:" + message[0].ConvertToString());
Console.WriteLine("Frame 1:" + fileName);
Console.WriteLine("Frame 2:" + data.Length);
var stream = File.OpenWrite(path + fileName);
stream.Write(data, 0, data.Length);
stream.Flush();
stream.Close();
Console.WriteLine("finished writing the file");
Console.ReadKey();
}
}
}
public MessageClient(string ip_address = "127.0.0.1",
int port = 6969,
bool use_inter_process_communication = false,
bool debug = false,
Double wait_time_seconds = 2)
{
this._wait_time_seconds = wait_time_seconds;
this.Debugging = debug;
this._ip_address = ip_address;
this._port = port;
this._use_inter_process_communication = use_inter_process_communication;
#if NEODROID_DEBUG
if (this.Debugging)
{
Debug.Log($"Starting a message server at address:port {ip_address}:{port}");
}
#endif
if (!this._use_inter_process_communication)
{
ForceDotNet.Force();
}
this._socket = new ResponseSocket();
}
/// <summary>
/// protocol for NetMq
/// the <message> should be a string send as the second frame and the message must not contain more that two frames or it will be discarded by the server
/// "A" as first frame if you want <message> + " hello" as response
/// "B" as first frame if you want "hello " + <message>
/// </summary>
static void Main(string[] args)
{
Console.WriteLine("NetMQ server have started");
var server = new ResponseSocket();
server.Bind("tcp://*:" + ListeningPort);
while (true)
{
var message = server.ReceiveMultipartMessage();
if (message.FrameCount == 2)
{
var frameOne = message[0];
Console.WriteLine("recived message with protocol code: " + frameOne.ConvertToString());
//sending response
if (frameOne.ConvertToString() == "A")
{
server.SendFrame(message[1].ConvertToString() + " hello");
continue;
}
else if (frameOne.ConvertToString() == "B")
{
server.SendFrame(message[1].ConvertToString() + " hello");
continue;
}
}
//must only occure if the message is not valid according to the protocol
server.SendFrame("INVALID FRAME COUNT!");
}
}
static void Main(string[] args)
{
Console.WriteLine("Tier 3 here");
var reciveSocket = new ResponseSocket();
reciveSocket.Bind("tcp://0.0.0.0:" + listeningPort);
var multipartMessage = reciveSocket.ReceiveMultipartMessage();
var frames = new List <NetMQFrame>();
while (false == multipartMessage.IsEmpty)
{
frames.Add(multipartMessage.Pop());
}
Console.WriteLine(frames[3]);
while (frames.Count > 2)
{
frames.RemoveAt(2);
}
frames.Add(new NetMQFrame("Yes this is from server three"));
var responseMessage = new NetMQMessage(frames);
reciveSocket.SendMultipartMessage(responseMessage);
Console.ReadKey();
}
void establish(Action BindEd)
{
ThreadPool.QueueUserWorkItem((o) => {
ConsoleEx.DebugLog("Respose socket is binding...", ConsoleEx.RED);
var context = Core.ZeroMQ;
respSocket = context.CreateResponseSocket();
respSocket.Options.SendHighWatermark = EngCfg.HighWatermark;
respSocket.Options.ReceiveHighWatermark = EngCfg.HighWatermark;
//生成通讯地址和协议方式
BindingAddress = BindAddr(typeof(ResponseSocket));
respSocket.Bind(BindingAddress);
///
/// 绑定完成，等待Request的请求
///
respSocket.ReceiveReady += Server_ReceiveReady;
poller.AddSocket(respSocket);
ThreadPool.QueueUserWorkItem((ob) => { poller.PollTillCancelled(); });
if (BindEd != null)
{
BindEd();
}
});
}
public Listener()
{
working = true;
listener = new Thread(new ThreadStart(() =>
{
server = new ResponseSocket();
server.Bind("tcp://*:5554");
string message;
while (working)
{
if (server.TryReceiveFrameString(System.TimeSpan.FromSeconds(2), out message))
{
Console.WriteLine("receive message: {0}", message);
var message_obj = json_converter.JsonConverter.deserialaze(message);
ProcessMessage(message_obj as iMessage);
}
else
{
Console.WriteLine("No message recieve");
}
}
}));
listener.IsBackground = true;
}
public void setupServer()
{
using (var server = new ResponseSocket())
{
server.Bind("tcp://*:5555");
while (true)
{
var message = server.ReceiveFrameString();
Console.WriteLine(" Message Received on Server {0}", message);
Thread.Sleep(200);
server.SendFrame("World");
Console.WriteLine(" This is master changes that i need in feature branch");
Console.WriteLine(" BRanch changes ");
Console.WriteLine(" This is master changes that i need in feature branch +1 ");
Console.WriteLine(" This is master changes that i need in feature branch +2");
Console.WriteLine(" This is master changes that i need in feature branch +3");
Console.WriteLine(" This is master changes that i need in feature branch +4");
Console.WriteLine(" This is master changes that i need in feature branch +5");
Console.WriteLine(" This is master changes that i need in feature branch +4");
Console.WriteLine(" This is master changes that i need in feature branch +6");
Console.WriteLine(" This is master changes that i need in feature branch +7");
Console.WriteLine(" This is master changes that i need in feature branch +8");
Console.WriteLine(" This is master changes that i need in feature branch +9");
Console.WriteLine(" BRanch changes ");
}
}
}
public void StartAndStopStateValidation()
{
using (var front = new RouterSocket())
using (var back = new DealerSocket())
{
front.Bind("inproc://frontend");
back.Bind("inproc://backend");
var proxy = new Proxy(front, back);
Task.Factory.StartNew(proxy.Start);
// Send a message through to ensure the proxy has started
using (var client = new RequestSocket())
using (var server = new ResponseSocket())
{
client.Connect("inproc://frontend");
server.Connect("inproc://backend");
client.SendFrame("hello");
Assert.AreEqual("hello", server.ReceiveFrameString());
server.SendFrame("reply");
Assert.AreEqual("reply", client.ReceiveFrameString());
}
Assert.Throws <InvalidOperationException>(proxy.Start);
Assert.Throws <InvalidOperationException>(proxy.Start);
Assert.Throws <InvalidOperationException>(proxy.Start);
proxy.Stop(); // blocks until stopped
Assert.Throws <InvalidOperationException>(proxy.Stop);
}
}
static void Main(string[] args)
{
var rand = new Random();
while (true)
{
// specify one ephemeral port
int port = rand.Next(49152, 65535);
string address = $"tcp://*****:*****@{address}"))
using (var client = new RequestSocket($">{address}"))
{
while (true)
{
client.SendFrame("Hello");
Console.WriteLine($"From client: {server.ReceiveFrameString()}");
server.SendFrame("Hi Back");
Console.WriteLine($"From server: {client.ReceiveFrameString()}");
Thread.Sleep(1000);
}
}
}
catch (AddressAlreadyInUseException)
{
Console.WriteLine($"This address is in use. Let's pick onther one.");
}
}
}
/// <summary>
/// Start listening on udp port
/// </summary>
public override void Start()
{
if (_listen) return;
try
{
Log.Info("PortZMq starting");
Log.Debug(string.Format("Publisher binding on {0}", _endpoint));
_res = new ResponseSocket();
_res.Bind(_localpoint);
_listen = true;
new Thread(() =>
{
try
{
while (_listen)
{
byte[] data;
while ((_res != null) && _res.HasIn)
if (_res.TryReceiveFrameBytes(TimeSpan.FromSeconds(30), out data))
{
Log.Debug(string.Format("Received {0} bytes", data.Length));
//Process received data
if (!ProcessData(data, data.Length))
{
_res.SignalError();
Log.Error(string.Format("Processing {0} bytes failed", data.Length));
}
else
{
_res.SignalOK();
Log.Debug(string.Format("Processed {0} bytes", data.Length));
}
}
}
}
catch (Exception e)
{
Log.Error("PortZMq loop error", e);
}
}).Start();
base.Start();
}
catch (Exception e)
{
Log.Error("PortZMq start error", e);
}
}
public AsyncWorker(int id, NetMQContext context, string address) : base(id)
{
_responseSocket = context.CreateResponseSocket();
_responseSocket.Options.ReceiveHighWatermark = 2;
_responseSocket.Options.SendHighWatermark = 2;
_responseSocket.Options.Identity = BitConverter.GetBytes(id);
_responseSocket.Connect(address);
}
public Heartbeat(ILog logger, string address, NetMQContext context)
{
this.logger = logger;
this.address = address;
this.context = context;
this.server = context.CreateResponseSocket();
this.stopEvent = new ManualResetEventSlim();
}
public ReactiveServer()
{
var context = NetMQContext.Create();
repSocket = context.CreateResponseSocket();
repSocket.Bind("tcp://127.0.0.1:3334");
repSocket.ReceiveReady += RepSocketOnReceiveReady;
var repThread = new Thread(RepThread);
repThread.Start();
pubSocket = context.CreatePublisherSocket();
pubSocket.Bind("tcp://127.0.0.1:3333");
}
public CommandListener (int port, Dictionary<int, Job> jobs)
{
this.Port = port;
this.Jobs = jobs;
this.Context = NetMQContext.Create ();
this.RequestSock = Context.CreateResponseSocket ();
this.RequestSock.Bind ("tcp://0.0.0.0:" + Port);
logger.Info ("Bound to TCP port {0}", Port);
this.ResponseSock = Context.CreatePushSocket ();
this.ResponseSock.Bind ("tcp://0.0.0.0:" + (Port + 1));
logger.Info ("Bound callback to TCP port {0}", (Port + 1));
}
private static void Main()
{
using (var worker = new ResponseSocket())
{
worker.Connect(WorkerEndpoint);
while (true)
{
var msg = worker.ReceiveMultipartMessage();
Console.WriteLine("Processing Message {0}", msg.Last.ConvertToString());
Thread.Sleep(500);
worker.SendFrame(msg.Last.ConvertToString());
}
}
}
private static void Main()
{
Console.Title = "NetMQ HelloWorld";
using (var server = new ResponseSocket("@tcp://localhost:5556"))
using (var client = new RequestSocket("tcp://localhost:5556"))
{
client.SendFrame("Hello");
Console.WriteLine("From Client: {0}", server.ReceiveFrameString());
server.SendFrame("Hi Back");
Console.WriteLine("From Server: {0}", client.ReceiveFrameString());
Console.WriteLine();
Console.Write("Press any key to exit...");
Console.ReadKey();
}
}
private static void WorkerRoutine()
{
try
{
using (ResponseSocket rep = new ResponseSocket())
{
rep.Options.Identity = Encoding.Unicode.GetBytes(Guid.NewGuid().ToString());
rep.Connect("tcp://localhost:5556");
//rep.Connect("inproc://workers");
rep.ReceiveReady += RepOnReceiveReady;
while (!s_token.IsCancellationRequested)
{
rep.Poll(TimeSpan.FromMilliseconds(100));
}
}
}
catch (Exception ex)
{
Console.WriteLine("Exception on WorkerRoutine: {0}", ex.Message);
throw;
}
}
private static void Main()
{
using (var response = new ResponseSocket())
{
string address = GetComputerLanIP();
if (!string.IsNullOrEmpty(address))
{
Console.WriteLine("Binding tcp://{0}:{1}", address, PortNumber);
response.Bind(string.Format("tcp://{0}:{1}", address, PortNumber));
while (true)
{
bool hasMore;
string msg = response.ReceiveFrameString(out hasMore);
if (string.IsNullOrEmpty(msg))
{
Console.WriteLine("No msg received.");
break;
}
Console.WriteLine("Msg received! {0}", msg);
response.SendFrame(msg, hasMore);
Thread.Sleep(1000);
}
response.Options.Linger = TimeSpan.Zero;
}
else
{
Console.WriteLine("Wrong IP address");
}
Console.WriteLine("Press any key to exit...");
Console.ReadKey();
}
}
private static int Main(string[] args)
{
if (args.Length != 3)
{
Console.WriteLine("usage: local_lat <bind-to> <message-size> <roundtrip-count>");
return 1;
}
string bindTo = args[0];
int messageSize = int.Parse(args[1]);
int roundtripCount = int.Parse(args[2]);
using (var rep = new ResponseSocket())
{
rep.Bind(bindTo);
var msg = new Msg();
msg.InitEmpty();
for (int i = 0; i != roundtripCount; i++)
{
rep.Receive(ref msg);
if (msg.Size != messageSize)
{
Console.WriteLine("message of incorrect size received. Received: " + msg.Size + " Expected: " + messageSize);
return -1;
}
rep.Send(ref msg, more: false);
}
msg.Close();
}
return 0;
}
private static void Main()
{
Console.Title = "NetMQ LazyPirate Server 2";
const string serverEndpoint = "tcp://127.0.0.1:5555";
var random = new Random();
using (var server = new ResponseSocket())
{
Console.WriteLine("S: Binding address {0}", serverEndpoint);
server.Bind(serverEndpoint);
var cycles = 0;
while (true)
{
var request = server.ReceiveFrameString();
cycles++;
if (cycles > 3 && random.Next(0, 10) == 0)
{
Console.WriteLine("S: Simulating a crash");
Thread.Sleep(5000);
}
else if (cycles > 3 && random.Next(0, 10) == 0)
{
Console.WriteLine("S: Simulating CPU overload");
Thread.Sleep(1000);
}
Console.WriteLine("S: Normal request ({0})", request);
server.SendFrame(request);
}
}
}
public void HandleFrameMessage(ResponseSocket server, NetMQMessage msg)
{
Debug.Log ("Handling Message");
if (logTimingInfo || logSimpleTimeInfo)
{
DateTime newTime = DateTime.Now;
Debug.LogFormat("Time since received last msg: {0} ms", newTime.Subtract(_timeForLastMsg).TotalMilliseconds);
_timeForLastMsg = newTime;
}
if (debugNetworkMessages)
Debug.LogFormat("Received Msg on Server: {0}", ReadOutMessage(msg));
string msgHeader = msg.First.ConvertToString();
JsonData jsonData = msg.ReadJson(out msgHeader);
if (jsonData == null)
{
Debug.LogError("Invalid message from client! Cannot parse JSON!\n" + ReadOutMessage(msg));
return;
}
if (msgHeader == null)
{
Debug.LogError("Invalid message from client! No msg_type!\n" + jsonData.ToJSON());
return;
}
switch(msgHeader.ToString())
{
case MSG_R_Terminate:
Application.Quit ();
break;
case MSG_R_ClientJoin:
OnClientJoin(server, jsonData);
RecieveClientInput(server, jsonData);
break;
case MSG_R_FrameInput:
RecieveClientInput(server, jsonData);
break;
case MSG_R_ClientJoinWithConfig:
Debug.Log ("Config received!");
ReceiveSceneSwitch (server, jsonData);
Debug.Log ("Config handled!");
break;
case MSG_R_SceneSwitch:
ReceiveSceneSwitch(server, jsonData);
break;
default:
Debug.LogWarningFormat("Invalid message from client! Unknown msg_type '{0}'\n{1}", msgHeader, jsonData.ToJSON());
break;
}
}
public void OnClientJoin(ResponseSocket server, JsonData data)
{
// Setup new avatar object from prefab
GameObject newGameObject = Instantiate (Resources.Load ("Prefabs/Avatar")) as GameObject;
Debug.Log (newGameObject.name);
Avatar newAvatar = newGameObject.GetComponent<Avatar> ();
if (_avatars.ContainsKey(server))
{
Avatar oldAvatar = _avatars[server];
if (oldAvatar != null && oldAvatar.gameObject != null)
GameObject.Destroy(_avatars[server].gameObject);
}
_avatars[server] = newAvatar;
newAvatar.InitNetData(this, server);
newAvatar.sendSceneInfo = data["send_scene_info"].ReadBool(false);
newAvatar.shouldCollectObjectInfo = data["get_obj_data"].ReadBool(false);
//
// // Send confirmation message
// lastMessageSent.Clear();
// lastMessageSent.Append(MSG_S_ConfirmClientJoin);
// server.SendMultipartMessage(lastMessageSent);
}
public void ReceiveSceneSwitch(ResponseSocket server, JsonData jsonData)
{
string newEnvironmentScene = jsonData["config"]["environment_scene"].ReadString ("MISSING SCENE TYPE!");
SimulationManager.setArgsConfig (jsonData["config"]);
Debug.Log ("Scene config: " + jsonData ["config"].ToJSON ());
//Debug.Log("Scale Related Dict: " + SimulationManager.argsConfig["scale_relat_dict"]["bed1"]["option"].ToJSON());
this.scenesToUnload = new List<Scene> ();
// Unload old scene(s)
for (int i = 0; i < SceneManager.sceneCount; i++) {
Scene sceneAtIndex = SceneManager.GetSceneAt (i);
if (sceneAtIndex.path.StartsWith ("Assets/Scenes/EnvironmentScenes/")) {
Debug.Log ("Queueing scene unload for: " + sceneAtIndex.name);
this.scenesToUnload.Add (sceneAtIndex);
}
}
Debug.Log ("Loading \'" + newEnvironmentScene + "\'");
// Load new scene
SceneManager.LoadScene (newEnvironmentScene, LoadSceneMode.Additive);
if (!SceneManager.GetSceneByName (newEnvironmentScene).IsValid()) {
Debug.LogError ("Scene name \"" + newEnvironmentScene + "\" was not found.");
}
if (!SceneManager.GetSceneByName (newEnvironmentScene).path.StartsWith ("Assets/Scenes/EnvironmentScenes/")) {
Debug.LogError ("Scene is not located in Assets/Scenes/EnvironmentScenes/, please relocate scene file to this directory!");
}
SceneManager.sceneLoaded += sceneWasLoaded;
this.skipFrame = true;
this.waitForSceneInit = true;
this.lastSocket = server;
this.lastJsonContents = jsonData;
}
public void RecieveClientInput(ResponseSocket server, JsonData jsonData)
{
_avatars[server].HandleNetInput(jsonData);
}
private void CreateTestClient(ResponseSocket server)
{
RequestSocket client = _ctx.CreateRequestSocket();
client.Connect("tcp://" + hostAddress + ":" + portNumber);
_avatarClients[server] = client;
client.SendFrame(CreateJoinMsgJson().ToJSON());
}
public void OnClientJoin(ResponseSocket server, JsonData data)
{
// Setup new avatar object from prefab
GameObject newGameObject = Instantiate (Resources.Load ("Prefabs/Avatar")) as GameObject;
Debug.Log (newGameObject.name);
Avatar newAvatar = newGameObject.GetComponent<Avatar> ();
if (_avatars.ContainsKey(server))
{
Avatar oldAvatar = _avatars[server];
if (oldAvatar != null && oldAvatar.gameObject != null)
GameObject.Destroy(_avatars[server].gameObject);
}
_avatars[server] = newAvatar;
newAvatar.InitNetData(this, server);
newAvatar.sendSceneInfo = data["send_scene_info"].ReadBool(false);
newAvatar.shouldCollectObjectInfo = data["get_obj_data"].ReadBool(false);
//TODO
JsonData JsonOutputFormatList = data["output_formats"];
if (JsonOutputFormatList != null) {
if (JsonOutputFormatList.Count != newAvatar.outputFormatList.Count) {
Debug.LogError(newAvatar.outputFormatList.Count.ToString() +
" output formats need to be specified, one for each shader!" +
" Using standard output formats.");
}
List<string> outputFormatList = new List<string>();
for(int i = 0; i < JsonOutputFormatList.Count; i++) {
string outputFormat = JsonOutputFormatList[i].ReadString();
outputFormatList.Add(outputFormat);
}
newAvatar.SetOutputFormatList(outputFormatList);
}
//
// // Send confirmation message
// lastMessageSent.Clear();
// lastMessageSent.Append(MSG_S_ConfirmClientJoin);
// server.SendMultipartMessage(lastMessageSent);
}
