public void ProcessMessage(ReferenceCountedSceneGraphMessage message)
{
// the other end has taken control of this object
owner = false;
rb.isKinematic = true;
var state = message.FromJson <TransformMessage>();
transform.localPosition = state.position;
transform.localRotation = state.rotation;
}
public void ProcessMessage(ReferenceCountedSceneGraphMessage message)
{
var hash = sha526.ComputeHash(message.bytes, message.start, message.length - hashLength);
var compare = new ReadOnlySpan <byte>(message.bytes, message.start + message.length - hashLength, hashLength).SequenceEqual(hash);
if (!compare)
{
Debug.LogError("Message Corruption Detected");
}
received++;
}
public void ProcessMessage(ReferenceCountedSceneGraphMessage data)
{
try
{
OnRtcMessage(data.FromJson<Message>());
}
catch (Exception e)
{
Debug.LogException(e);
return;
}
}
public void ProcessMessage(ReferenceCountedSceneGraphMessage message)
{
var msg = JsonUtility.FromJson <Message>(message.ToString());
switch (msg.type)
{
case "RequestPeerConnection":
logger.Log("CreatePeerConnectionForRequest", msg.objectid);
var pc = CreatePeerConnection(msg.objectid, msg.uuid, polite: false);
break;
}
}
private void Send()
{
// Co-ords from hints are already in local to our network scene
// so we can send them without any changes
var transformBytes = MemoryMarshal.AsBytes(new ReadOnlySpan <State>(state));
var message = ReferenceCountedSceneGraphMessage.Rent(transformBytes.Length);
transformBytes.CopyTo(new Span <byte>(message.bytes, message.start, message.length));
context.Send(message);
}
public void ProcessMessage(ReferenceCountedSceneGraphMessage message)
{
var msg = JsonUtility.FromJson <Message>(message.ToString());
switch (msg.type)
{
case "RequestPeerConnection":
var pc = CreatePeerConnection(msg.objectid, msg.uuid);
pc.stats.peer = msg.uuid;
pc.AddLocalAudioSource();
break;
}
}
public void ProcessMessage(ReferenceCountedSceneGraphMessage data)
{
var message = data.FromJson <Message>();
// Buffer messages until the RtcPeerConnection is initialised
if (rtcPeerConnection == null)
{
messageQueue.Enqueue(message);
}
else
{
DoProcessMessage(message);
}
}
public void ProcessMessage(ReferenceCountedSceneGraphMessage message)
{
if (!isMePressStartButton)
{
var msg = message.FromJson <Message>();
spendTime = msg.time;
distroyflag = msg.distroyflag;
/*if (!isgetposition)
* {
* ClosePanel.transform.position = msg.position;
* isgetposition = true;
* }*/
}
}
public void ProcessMessage(ReferenceCountedSceneGraphMessage message)
{
if (transforms == null || transforms.Length != flock.boids.Length)
{
transforms = new TransformMessage[flock.boids.Length];
}
MemoryMarshal.Cast <byte, TransformMessage>(
new ReadOnlySpan <byte>(message.bytes, message.start, message.length))
.CopyTo(
new Span <TransformMessage>(transforms));
for (int i = 0; i < flock.boids.Length; i++)
{
flock.boids[i].transform.localPosition = transforms[i].position;
flock.boids[i].transform.localRotation = transforms[i].rotation;
}
}
private void Send()
{
if (transforms == null || transforms.Length != flock.boids.Length)
{
transforms = new TransformMessage[flock.boids.Length];
}
for (int i = 0; i < flock.boids.Length; i++)
{
transforms[i].position = flock.boids[i].transform.localPosition;
transforms[i].rotation = flock.boids[i].transform.localRotation;
}
var transformsBytes = MemoryMarshal.AsBytes(new ReadOnlySpan <TransformMessage>(transforms));
var message = ReferenceCountedSceneGraphMessage.Rent(transformsBytes.Length);
transformsBytes.CopyTo(new Span <byte>(message.bytes, message.start, message.length));
context.Send(message);
}
public void ProcessMessage(ReferenceCountedSceneGraphMessage message)
{
var length = bones.Length + 1;
if (transforms == null || transforms.Length != length)
{
transforms = new TransformMessage[length];
}
MemoryMarshal.Cast <byte, TransformMessage>(
new ReadOnlySpan <byte>(message.bytes, message.start, message.length))
.CopyTo(
new Span <TransformMessage>(transforms));
for (int i = 0; i < bones.Length; i++)
{
bones[i].localPosition = transforms[i + 1].position;
bones[i].localRotation = transforms[i + 1].rotation;
}
transform.localPosition = transforms[0].position;
transform.localRotation = transforms[0].rotation;
}
// Update is called once per frame
void Update()
{
if (run)
{
for (int i = 0; i < messagesPerFrame; i++)
{
if (sent >= totalMessages)
{
return;
}
int length = UnityEngine.Random.Range(hashLength + 2, maxMessageSize);
var message = ReferenceCountedSceneGraphMessage.Rent(length);
var datalength = length - hashLength;
for (int j = 0; j < datalength; j++)
{
message.bytes[message.start + j] = (byte)UnityEngine.Random.Range(0, 255);
}
Array.Copy(sha526.ComputeHash(message.bytes, message.start, datalength), 0, message.bytes, message.start + datalength, hashLength);
if (corrupt)
{
for (int j = 0; j < datalength; j++)
{
message.bytes[message.start + j] = (byte)UnityEngine.Random.Range(0, 255);
}
}
context.Send(message);
sent++;
}
}
}
public LogManagerMessage(ReferenceCountedSceneGraphMessage message)
{
this.buffer = message;
}
public void ProcessMessage(ReferenceCountedSceneGraphMessage message)
{
meter.Volume = message.FromJson <Message>().volume;
}
public void ProcessMessage(ReferenceCountedSceneGraphMessage message)
{
}
public void ProcessMessage(ReferenceCountedSceneGraphMessage message)
{
var m = JsonUtility.FromJson <Message>(message.ToString());
transform.localPosition = m.position;
}
public void Send(ReferenceCountedSceneGraphMessage m)
{
connection.Send(m.buffer);
}
public void ProcessMessage(ReferenceCountedSceneGraphMessage message)
{
var msg = message.FromJson <Message>();
Instantiate(msg.catalogueIndex, msg.networkId, false);
}
private void Update()
{
foreach (var client in clients)
{
while (true)
{
var buffer = client.connection.Receive();
if (buffer == null)
{
break;
}
try
{
var message = new ReferenceCountedSceneGraphMessage(buffer);
// check if this message is meant for us, or if we are to forward it
if (message.objectid == this.objectId)
{
var container = JsonUtility.FromJson <Message>(message.ToString());
switch (container.type)
{
case "Join":
var joinArgs = JsonUtility.FromJson <JoinArgs>(container.args);
client.peer = joinArgs.peer;
room.Join(client);
break;
case "UpdatePeer":
client.peer = JsonUtility.FromJson <PeerInfo>(container.args);
if (client.room != null)
{
client.room.SendPeerUpdate(client.peer);
}
break;
case "UpdateRoom":
room.SetRoomArgs(JsonUtility.FromJson <RoomInfo>(container.args));
break;
case "RequestRooms":
client.SendRooms(AvailableRooms);
break;
case "":
break;
}
}
else
{
if (client.room != null) // if it is a member of a room...
{
foreach (var item in client.room.clients)
{
if (item != client)
{
message.Acquire();
item.Send(message);
}
}
}
}
}
finally
{
buffer.Release();
}
}
}
// actions to be taken once outside the enumators (e.g. removing items from the lists...)
foreach (var item in actions)
{
item();
}
actions.Clear();
}
public void ProcessMessage(ReferenceCountedSceneGraphMessage message)
{
JsonUtility.FromJsonOverwrite(message.ToString(), state);
}
public void ProcessMessage(ReferenceCountedSceneGraphMessage message)
{
conversationBox.text += message.ToString() + "\n";
}
