public static unsafe void Process(InputRemoting receiver, Message msg)
            {
                var manager = receiver.m_LocalManager;

                fixed(byte *dataPtr = msg.data)
                {
                    var dataEndPtr  = new IntPtr(dataPtr + msg.data.Length);
                    var eventCount  = 0;
                    var eventPtr    = new InputEventPtr((InputEvent *)dataPtr);
                    var senderIndex = receiver.FindOrCreateSenderRecord(msg.participantId);

                    while ((Int64)eventPtr.data < dataEndPtr.ToInt64())
                    {
                        // Patch up device ID to refer to local device and send event.
                        var remoteDeviceId = eventPtr.deviceId;
                        var localDeviceId  = receiver.FindLocalDeviceId(remoteDeviceId, senderIndex);
                        eventPtr.deviceId = localDeviceId;

                        if (localDeviceId != InputDevice.InvalidDeviceId)
                        {
                            ////TODO: add API to send events in bulk rather than one by one
                            manager.QueueEvent(eventPtr);
                        }

                        ++eventCount;
                        eventPtr = eventPtr.Next();
                    }
                }
            }
            public static void Process(InputRemoting receiver, Message msg)
            {
                ////REVIEW: we probably don't want to do this blindly
                var layoutName = Encoding.UTF8.GetString(msg.data);

                receiver.m_LocalManager.RemoveControlLayout(layoutName);
            }
            public static unsafe Message Create(InputRemoting sender, InputEvent *events, int eventCount)
            {
                // Find total size of event buffer we need.
                var totalSize = 0u;
                var eventPtr  = new InputEventPtr(events);

                for (var i = 0; i < eventCount; ++i, eventPtr = eventPtr.Next())
                {
                    totalSize += eventPtr.sizeInBytes;
                }

                // Copy event data to buffer. Would be nice if we didn't have to do that
                // but unfortunately we need a byte[] and can't just pass the 'events' IntPtr
                // directly.
                var data = new byte[totalSize];

                fixed(byte *dataPtr = data)
                {
                    UnsafeUtility.MemCpy(dataPtr, events, totalSize);
                }

                // Done.
                return(new Message
                {
                    type = MessageType.NewEvents,
                    data = data
                });
            }
            public static Message?Create(InputRemoting sender, string layoutName)
            {
                // Try to load the layout. Ignore the layout if it couldn't
                // be loaded.
                InputControlLayout layout;

                try
                {
                    layout = sender.m_LocalManager.TryLoadControlLayout(new InternedString(layoutName));
                    if (layout == null)
                    {
                        Debug.Log(string.Format(
                                      "Could not find layout '{0}' meant to be sent through remote connection; this should not happen",
                                      layoutName));
                        return(null);
                    }
                }
                catch (Exception exception)
                {
                    Debug.Log(string.Format(
                                  "Could not load layout '{0}'; not sending to remote listeners (exception: {1})", layoutName,
                                  exception));
                    return(null);
                }

                var json  = layout.ToJson();
                var bytes = Encoding.UTF8.GetBytes(json);

                return(new Message
                {
                    type = MessageType.NewLayout,
                    data = bytes
                });
            }
            public static void Process(InputRemoting receiver, Message msg)
            {
                Debug.Log("DisconnectMsg.Process");

                receiver.RemoveRemoteDevices(msg.participantId);
                receiver.StopSending();
            }
 public static Message Create(InputRemoting sender, InputDevice device)
 {
     return(new Message
     {
         type = MessageType.RemoveDevice,
         data = BitConverter.GetBytes(device.id)
     });
 }
            public static void Process(InputRemoting receiver, Message msg)
            {
                var json        = Encoding.UTF8.GetString(msg.data);
                var senderIndex = receiver.FindOrCreateSenderRecord(msg.participantId);

                receiver.m_LocalManager.RegisterControlLayout(json);
                ArrayHelpers.Append(ref receiver.m_Senders[senderIndex].layouts, json);
            }
            public static Message Create(InputRemoting sender, string layoutName)
            {
                var bytes = Encoding.UTF8.GetBytes(layoutName);

                return(new Message
                {
                    type = MessageType.RemoveLayout,
                    data = bytes
                });
            }
 public static void Process(InputRemoting receiver, Message msg)
 {
     if (receiver.sending)
     {
         receiver.SendAllDevices();
     }
     else if ((receiver.m_Flags & Flags.StartSendingOnConnect) == Flags.StartSendingOnConnect)
     {
         receiver.StartSending();
     }
 }
            public static void Process(InputRemoting receiver, Message msg)
            {
                var senderIndex    = receiver.FindOrCreateSenderRecord(msg.participantId);
                var remoteDeviceId = BitConverter.ToInt32(msg.data, 0);

                var device = receiver.TryGetDeviceByRemoteId(remoteDeviceId, senderIndex);

                if (device != null)
                {
                    receiver.m_LocalManager.RemoveDevice(device);
                }
            }
            public static void Process(InputRemoting receiver, Message msg)
            {
                var senderIndex = receiver.FindOrCreateSenderRecord(msg.participantId);
                var data        = DeserializeData <Data>(msg.data);

                // Make sure we haven't already seen the device.
                var devices = receiver.m_Senders[senderIndex].devices;

                if (devices != null)
                {
                    foreach (var entry in devices)
                    {
                        if (entry.remoteId == data.deviceId)
                        {
                            Debug.LogError(string.Format(
                                               "Already received device with id {0} (layout '{1}', description '{3}) from remote {2}",
                                               data.deviceId,
                                               data.layout, msg.participantId, data.description));
                            return;
                        }
                    }
                }

                // Create device.
                InputDevice device;

                try
                {
                    ////REVIEW: this gives remote devices names the same way that local devices receive them; should we make remote status visible in the name?
                    device = receiver.m_LocalManager.AddDevice(data.layout);
                    device.m_ParticipantId = msg.participantId;
                }
                catch (Exception exception)
                {
                    Debug.LogError(
                        $"Could not create remote device '{data.description}' with layout '{data.layout}' locally (exception: {exception})");
                    return;
                }
                device.m_Description  = data.description;
                device.m_DeviceFlags |= InputDevice.DeviceFlags.Remote;

                // Remember it.
                var record = new RemoteInputDevice
                {
                    remoteId    = data.deviceId,
                    localId     = device.id,
                    description = data.description,
                    layoutName  = data.layout
                };

                ArrayHelpers.Append(ref receiver.m_Senders[senderIndex].devices, record);
            }
            public static Message Create(InputRemoting sender, InputDevice device)
            {
                var data = new Data
                {
                    deviceId = device.id,
                    usages   = device.usages.Select(x => x.ToString()).ToArray()
                };

                return(new Message
                {
                    type = MessageType.ChangeUsages,
                    data = SerializeData(data)
                });
            }
            public static void Process(InputRemoting receiver, Message msg)
            {
                var senderIndex = receiver.FindOrCreateSenderRecord(msg.participantId);
                var data        = DeserializeData <Data>(msg.data);

                var device = receiver.TryGetDeviceByRemoteId(data.deviceId, senderIndex);

                if (device != null)
                {
                    ////TODO: clearing usages and setting multiple usages

                    if (data.usages.Length == 1)
                    {
                        receiver.m_LocalManager.SetUsage(device, new InternedString(data.usages[0]));
                    }
                }
            }
            public static Message Create(InputRemoting sender, InputDevice device)
            {
                Debug.Assert(!device.remote, "Device being sent to remotes should be a local device, not a remote one");

                var data = new Data
                {
                    name        = device.name,
                    layout      = device.layout,
                    deviceId    = device.id,
                    description = device.description
                };

                var json  = JsonUtility.ToJson(data);
                var bytes = Encoding.UTF8.GetBytes(json);

                return(new Message
                {
                    type = MessageType.NewDevice,
                    data = bytes
                });
            }
 public static void Process(InputRemoting receiver, Message msg)
 {
     receiver.StopSending();
 }
Exemple #16
0
 public static void Process(InputRemoting receiver)
 {
     receiver.StartSending();
 }