void Update()
{
// If we are going to send 'as bundle', then we would like OSC io
// to add the timetag to the messeges contained in the bundle.
oscIn.addTimeTagsToBundledMessages = sendAsBundle;
// Create a messege
OscMessage message = new OscMessage( address );
// Create a timetag. Default time is DateTime.Now.
OscTimeTag timetag = new OscTimeTag();
// Make it 1 milisecond into the future.
timetag.time = timetag.time.AddMilliseconds( 1 );
// Two possible methods for sending timetags ...
if( sendAsBundle )
{
// Either create a bundle with the timetag, add the message and send.
OscBundle bundle = new OscBundle( timetag );
bundle.Add( message );
oscOut.Send( bundle );
} else {
// Or add the timetag to message and send it.
message.Add( timetag );
oscOut.Send( message );
}
// Update label.
sendLabel.text = timetag.time + ":" + timetag.time.Millisecond;
}
private static OscBundle CreateTestBundle()
{
IPEndPoint sourceEndPoint = new IPEndPoint(IPAddress.Loopback, Port);
OscBundle bundle = new OscBundle(sourceEndPoint);
OscBundle nestedBundle = new OscBundle(sourceEndPoint);
OscMessage nestedMessage = new OscMessage(sourceEndPoint, TestMethod);
nestedMessage.AppendNil();
nestedMessage.Append("Some String");
nestedMessage.Append(10);
nestedMessage.Append(100000L);
nestedMessage.Append(1234.567f);
nestedMessage.Append(10.0012345);
nestedMessage.Append(new byte[] { 1, 2, 3, 4 });
nestedMessage.Append(new OscTimeTag());
nestedMessage.Append('c');
nestedMessage.Append(Color.DarkGoldenrod);
nestedMessage.Append(true);
nestedMessage.Append(false);
nestedMessage.Append(float.PositiveInfinity);
nestedBundle.Append(nestedMessage);
bundle.Append(nestedBundle);
OscMessage message = new OscMessage(sourceEndPoint, AliveMethod);
message.Append(9876.543f);
bundle.Append(message);
return bundle;
}
// sends the messages stored in messagesThisFrame as a bundle, then clears messagesThisFrame
private void SendBundle()
{
OscBundle frameBundle = new OscBundle(localEndPoint);
foreach (OscMessage message in messagesThisFrame)
{
frameBundle.Append(message);
}
//UnityEngine.Debug.Log("sending bundle");
frameBundle.Send(externalEndPoint);
messagesThisFrame.Clear();
}
/// <summary>
/// Appends the data.
/// Depending on your bundle mode the AppendData method works in a different way.
/// If you use bundles you can append multiple OscMessages.
/// If you don't use bundles (default) you append data to your OscMessage
/// We only can append data types that are supported by the OSC specification:
///(Int32,Int64,Single,Double,String,Byte[],OscTimeTag,Char,Color,Boolean)
/// </summary>
/// <param name="_data">_data.</param>
public void AppendData(object _data)
{
OscBundle bundle = _data as OscBundle;
// Debug.Log("UniOSCEventDispatcherCB.AppendData:" + (bundle != null).ToString());
if (_OSCpkg == null)
{
// if (bundle == null) { _SetupOSCMessage(false); } else { _SetupOSCMessage(true); }
_SetupOSCMessage(bundle != null);
// return;
}
if (_OSCpkg is OscBundle)
{
if (bundle == null)
{
if (_data is OscMessage)
{
((OscBundle)_OSCpkg).Append(_data);
}
else
{
Debug.LogWarning("<color=orange>You can only append a OscMessage to a OscBundle</color>");
}
}
else
{
Debug.LogWarning("<color=orange>You can't append a OSCBundle to a OSCBundle</color>");
}
}
if (_OSCpkg is OscMessage)
{
if (bundle == null)
{
if (_data is OscMessage)
{
Debug.LogWarning("<color=orange>You can't append a OSCMessage to a OSCMessage</color>");
}
else
{
_OSCpkg.Append(_data);
}
}
else
{
Debug.LogWarning("<color=orange>You can't append a Bundle to a OSCMessage</color>");
}
}
}
private void Concentration(OscBundle data)
{
double value = parseDoubleFromString(data.Messages[0].Arguments[0].ToString());
Debug.Log(value);
if (value > 1)
{
ThinkingUp(100);
}
if (value < 1)
{
ThinkingDown(100);
}
}
public static String buildJSONBundle(String bundleName, OscBundle bundle)
{
String json = "[\"" + bundleName + "\",[";
var counter = 0;
foreach (OscElement element in bundle.Elements)
{
json += buildJSONElement(element);
json += counter == (bundle.Elements.Count - 1) ? "" : ",";
counter++;
}
json += "]]";
return(json);
}
public void TryParseTest_Good()
{
bool expected = true;
foreach (string str in UnitTestHelper.Bundles_Good)
{
OscBundle bundle = null;
bool actual;
actual = OscBundle.TryParse(str, out bundle);
Assert.True(expected == actual, $"While parsing good bundle '{str}'");
}
}
public void Nested_WriteTest()
{
OscBundle target = UnitTestHelper.DoubleNestedBundle();
byte[] data = new byte[UnitTestHelper.DoubleNestedBundleBody.Length];
int index = 0;
int expected = UnitTestHelper.DoubleNestedBundleBody.Length;
int actual;
actual = target.Write(data, index);
Assert.AreEqual(expected, actual);
UnitTestHelper.AreEqual(data, UnitTestHelper.DoubleNestedBundleBody);
}
private void handleOSC(OscPacket packet)
{
OscBundle p = (OscBundle)packet;
if (p != null)
{
int count = 0;
foreach (OscMessage m in p.Messages)
{
HandleOSCMeassage(m, count);
count++;
}
}
}
void Update()
{
// Create a bundle, add two messages with seperate addresses and values, then send.
OscBundle bundle = new OscBundle();
OscMessage message1 = new OscMessage( address1, Random.value );
OscMessage message2 = new OscMessage( address2, Random.value );
bundle.Add( message1 );
bundle.Add( message2 );
oscOut.Send( bundle );
// Update UI.
sendLabel1.text = message1.ToString();
sendLabel2.text = message2.ToString();
}
private bool ShouldProcessPackage(OscPacket packet)
{
if (packet is OscBundle == false)
{
return(true);
}
OscBundle bundle = packet as OscBundle;
if (bundle.Count == 0)
{
return(true);
}
if (bundle[0] is OscMessage == false)
{
return(true);
}
OscMessage message = bundle[0] as OscMessage;
if (message.Address != OscPackage.PackageAddress)
{
return(true);
}
if (message.Count == 0)
{
return(true);
}
if (message[0] is long == false)
{
return(true);
}
ulong id = unchecked ((ulong)(long)(message[0]));
if (activePackages.ContainsKey(id) == false)
{
return(true);
}
//Cancel(id);
PackageConfirmed?.Invoke(id);
return(false);
}
private void handleOSC(OscPacket packet)
{
OscBundle p = (OscBundle)packet;
if (p != null)
{
//Debug.Log("Receiving OSC");
int count = 0;
foreach (OscMessage m in p.Messages)
{
HandleOSCMeassage(m, count);
count++;
}
}
}
private void parseOscBundle(OscBundle bundle)
{
foreach (var message in bundle.Messages)
{
parseOscMessage(message);
}
if (bundle.Bundles.Count > 0)
{
foreach (var _bundle in bundle.Bundles)
{
parseOscBundle(_bundle);
}
}
}
public void ReadTest()
{
OscTimeTag timestamp = new OscTimeTag(14236589681638796952);
OscMessage[] messages = new OscMessage[] { UnitTestHelper.Message_Array_Ints(), UnitTestHelper.Message_Array_Ints() };
OscBundle expected = new OscBundle(timestamp, messages);
byte[] bytes = expected.ToByteArray();
int index = 0;
int count = bytes.Length;
OscBundle actual;
actual = OscBundle.Read(bytes, index, count);
UnitTestHelper.AreEqual(expected, actual);
Assert.IsTrue(actual.Equals(expected));
}
void ExtractMessages(OscPacket packet, Queue <OscMessage> list)
{
if (packet is OscMessage)
{
list.Enqueue(packet as OscMessage);
}
else
{
OscBundle bundle = packet as OscBundle;
foreach (OscPacket subPacket in bundle.packets)
{
ExtractMessages(subPacket, list);
}
}
}
/// <summary>
/// Recycle the specified bundle.
/// </summary>
public static void Recycle(OscBundle bundle)
{
if (bundle == null)
{
return;
}
if (_bundles.Count > saftyCapacity)
{
return;
}
if (!_bundles.Contains(bundle))
{
_bundles.Push(bundle);
}
}
private void rcvCb(OscPacket packet)
{
if (packet.IsBundle)
{
OscBundle bndl = packet as OscBundle;
foreach (OscMessage msg in bndl.Messages)
{
sendToClient(msg);
}
}
else
{
sendToClient(packet as OscMessage);
}
}
void Update()
{
// Create a bundle, add two messages with seperate addresses and values, then send.
OscBundle bundle = new OscBundle();
OscMessage message1 = new OscMessage(address1, Random.value);
OscMessage message2 = new OscMessage(address2, Random.value);
bundle.Add(message1);
bundle.Add(message2);
oscOut.Send(bundle);
// Update UI.
sendLabel1.text = message1.ToString();
sendLabel2.text = message2.ToString();
}
private void startUp()
{
hook = new UserActivityHook();
hook.KeyDown += (s, keycode, isCtrl) =>
{
OscElement msg = new OscElement(textOSC.Text, textId.Text, keycode.ToString());
OscBundle bundle = new OscBundle();
bundle.AddElement(msg);
oscmanager.Send(bundle);
textIndata.Text = keycode.ToString();
};
}
public void Send()
{
try
{
// bundle and send tuio data
//Debug.LogFormat("TUIO Cursors:{0} Objects:{1} Blobs:{2}", cursorCount, objectCount, blobCount);
bool sendKeepAliveCursors = (fseq % keepAliveInterval == keepAliveCursorsOffset);
bool sendKeepAliveObjects = (fseq % keepAliveInterval == keepAliveObjectsOffset);
bool sendKeepAliveBlobs = (fseq % keepAliveInterval == keepAliveBlobsOffset);
// send?
bool sendCursors = cursorsEnabled && (fseq == cursorsChangedFseq || sendKeepAliveCursors);
bool sendObjects = objectsEnabled && (fseq == objectsChangedFseq || sendKeepAliveObjects);
bool sendBlobs = blobsEnabled && (fseq == blobsChangedFseq || sendKeepAliveBlobs);
if (sendCursors || sendObjects || sendBlobs)
{
OscBundle oscBundle = new OscBundle();
if (sendCursors)
{
AppendToBundle <TUIOCursor>(oscBundle, sourceMessage2Dcur, aliveMessage2Dcur, fseqMessage2Dcur, sendKeepAliveCursors);
}
if (sendObjects)
{
AppendToBundle <TUIOObject>(oscBundle, sourceMessage2Dobj, aliveMessage2Dobj, fseqMessage2Dobj, sendKeepAliveObjects);
}
if (sendBlobs)
{
AppendToBundle <TUIOBlob>(oscBundle, sourceMessage2Dblb, aliveMessage2Dblb, fseqMessage2Dblb, sendKeepAliveBlobs);
}
udpTransmitter.Send(oscBundle);
// reset any previous error
hasError = false;
}
}
catch
{
hasError = true;
throw new SendTuioBundleException(string.Format("Error sending TUIO bundle to {0}:{1}", ipAddress, port));
}
finally
{
fseq++;
}
}
public static new bool FromBytes(byte[] data, ref int pos, int end, out OscPacket packet)
{
// Check header size
int bundleByteSize = end - pos;
if (bundleByteSize < headerByteSize)
{
Debug.LogWarning("[OSC io] OscBundle with invalid header was ignored." + Environment.NewLine);
packet = null;
return(false);
}
// Check prefix
string prefixInput = Encoding.ASCII.GetString(data, pos, prefixByteSize);
if (prefixInput != prefix)
{
Debug.LogWarning("[OSC io] OscBundle with invalid header was ignored." + Environment.NewLine);
packet = null;
return(false);
}
pos += prefixByteSize + 1; // + 1 to ensure bytes multiple of 4
// Get timetag
byte[] oscNtpBytes = new byte[OscTimeTag.byteSize];
Array.Copy(data, pos, oscNtpBytes, 0, OscTimeTag.byteSize);
OscTimeTag timeTag = new OscTimeTag(oscNtpBytes);
pos += OscTimeTag.byteSize;
// Create and fill bundle
packet = new OscBundle(timeTag);
OscBundle bundle = packet as OscBundle;
while (pos < end)
{
int length = BitConverter.ToInt32(data, 0);
pos += 4;
int packetEnd = pos + length;
OscPacket subPacket;
if (pos < end && OscPacket.FromBytes(data, ref pos, packetEnd, out subPacket))
{
bundle.Add(subPacket);
}
}
return(true);
}
private void UnpackMessages(MessageDirection direction, OscPacket packet)
{
if (packet is OscMessage)
{
OnMessage(direction, packet as OscMessage);
}
else if (packet is OscBundle)
{
OscBundle bundle = packet as OscBundle;
foreach (OscPacket sub in bundle)
{
UnpackMessages(direction, sub);
}
}
}
void InvokeAnyMessageEventRecursively(OscPacket packet)
{
if (packet is OscBundle)
{
OscBundle bundle = packet as OscBundle;
foreach (OscPacket subPacket in bundle.packets)
{
InvokeAnyMessageEventRecursively(subPacket);
}
}
else
{
onAnyMessage.Invoke(packet as OscMessage);
_messageCount++;
}
}
void SendAutoBundle()
{
if (_autoBundleMessageBuffer.count == 0)
{
return;
}
// Prepare for composing bundle.
_bundleTimeTag.time = _dateTime;
int sendBufferByteIndex = 0;
OscBundle.TryWriteHeader(_bundleTimeTag, _sendBuffer, ref sendBufferByteIndex);
// Loop through serialized messages in the end-of-frame-buffer.
int messageBufferByteIndex = 0;
for (int m = 0; m < _autoBundleMessageBuffer.count; m++)
{
// Get message size.
int messageSize = _autoBundleMessageBuffer.GetSize(m); // Bundle stores size of each message in a 4 byte integer.
// Check limit.
if (sendBufferByteIndex + FourByteOscData.byteCount + messageSize >= _sendBuffer.Length)
{
// We have reached the safety limit, now send the bundle.
TrySendBuffer(sendBufferByteIndex);
// Get ready for composing next bundle.
sendBufferByteIndex = OscConst.bundleHeaderSize;
}
// Write message size and data.
new FourByteOscData(messageSize).TryWriteTo(_sendBuffer, ref sendBufferByteIndex);
Array.Copy(_autoBundleMessageBuffer.data, messageBufferByteIndex, _sendBuffer, sendBufferByteIndex, messageSize);
messageBufferByteIndex += messageSize;
sendBufferByteIndex += messageSize;
}
// Send bundle if there is anything in it and clean.
if (sendBufferByteIndex > OscConst.bundleHeaderSize)
{
TrySendBuffer(sendBufferByteIndex);
}
_messageCountThisFrame += _autoBundleMessageBuffer.count;
_autoBundleMessageBuffer.Clear();
}
IEnumerator SendBundleOnEndOfFrame()
{
while (_bundleMessagesOnEndOfFrame)
{
// Wait.
yield return(_endOfFrameYield);
// Prepare for composing bundle.
_endOfFrameTimeTag.time = _dateTime;
int cacheIndex = 0;
OscBundle.TryWriteHeader(_endOfFrameTimeTag, _cache, ref cacheIndex);
// Loop through serialized messages in the end-of-frame-buffer.
int bufferIndex = 0;
for (int m = 0; m < _endOfFrameBuffer.count; m++)
{
// Compute size.
int messageSize = _endOfFrameBuffer.GetSize(m); // Bundle stores size of each message in a 4 byte integer.
// Check limit.
if (_splitBundlesAvoidingBufferOverflow && cacheIndex + FourByteOscData.byteCount + messageSize >= _udpBufferSize)
{
// We have reached the safelty limit, now send the bundle.
TrySendCache(cacheIndex);
// Get ready for composing next bundle.
cacheIndex = OscConst.bundleHeaderSize;
}
// Write message size and data.
new FourByteOscData(messageSize).TryWriteTo(_cache, ref cacheIndex);
Buffer.BlockCopy(_endOfFrameBuffer.data, bufferIndex, _cache, cacheIndex, messageSize);
bufferIndex += messageSize;
cacheIndex += messageSize;
}
// Send bundle if there is anything in it and clean.
if (cacheIndex > OscConst.bundleHeaderSize)
{
TrySendCache(cacheIndex);
}
_endOfFrameBuffer.Clear();
}
_endOfFrameCoroutine = null;
}
private void OnBundle(FROM from, OscBundle bundle)
{
for (int i = 0; i < bundle.Count; i++)
{
switch (bundle[i])
{
//Messageを受信した
case OscMessage msg:
OnMessage(from, msg);
break;
default:
//Do noting
break;
}
}
}
private OscBundle CreateBundle()
{
var ipAddress = _setting.UseLoopback ? IPAddress.Loopback : IPAddress.Parse(_setting.IpAddress);
var sourceEndPoint = new IPEndPoint(ipAddress, _setting.Port);
var bundle = new OscBundle(sourceEndPoint);
var nestedBundle = new OscBundle(sourceEndPoint);
foreach (var bindValue in _setting.BindValues)
{
var message = new OscMessage(sourceEndPoint, bindValue.Address);
message.Append(bindValue.Value);
nestedBundle.Append(message);
}
bundle.Append(nestedBundle);
return(bundle);
}
public OscClient Send(string address, bool convertDoubleToFloat, params object[] data)
{
// this.sender.WaitForAllMessagesToComplete();
this.log.Information("Sending to {0}", address);
if (data == null || data.Length == 0)
{
// Send empty message
var oscMessage = new OscMessage(address);
lock (lockObject)
{
this.sender.Send(oscMessage);
}
}
else
{
this.log.Information(" Data {0}", string.Join(" ", data));
var sendData = new object[data.Length];
for (int i = 0; i < data.Length; i++)
{
if (convertDoubleToFloat && data[i] is double)
{
sendData[i] = (float)((double)data[i]);
}
else
{
sendData[i] = data[i];
}
}
var oscMessage = new OscMessage(address, sendData);
var oscPacket = new OscBundle(0, oscMessage);
lock (lockObject)
{
this.sender.Send(oscPacket);
}
}
return(this);
}
// Update is called once per frame
protected void Update()
{
if (port == -1)
{
port = 12001;
}
OscBundle p = (OscBundle)listener.Receive();
if (p != null)
{
Debug.Log("Receiving OSC");
int count = 0;
foreach (OscMessage m in p.Messages)
{
HandleOSCMeassage(m, count);
count++;
}
}
}
public void OscBundleManyMessagesTest_1()
{
OscBundle expected = new OscBundle(new OscTimeTag(0),
new OscMessage("/ping"), new OscMessage("/moop"), new OscMessage("/ping"), new OscMessage("/ping"), new OscMessage("/ping"));
byte[] bytes = expected.ToByteArray();
OscBundleRaw actual = new OscBundleRaw(new ArraySegment <byte>(bytes, 0, bytes.Length));
Assert.Equal(actual.Count, expected.Count);
for (int i = 0; i < actual.Count; i++)
{
OscMessageRaw raw = actual[i];
OscMessage expectedMessage = expected[i] as OscMessage;
Assert.Equal(raw.Address, expectedMessage.Address);
}
}
private static void Serialise(OscBundle bundle, JsonTextWriter writer)
{
if (writer == null)
{
throw new ArgumentNullException("writer");
}
writer.WritePropertyName("address");
writer.WriteValue(bundle.Address);
writer.WritePropertyName("timeTag");
writer.WriteValue(bundle.TimeStamp.TimeTag);
var messages = bundle.Messages;
if (messages != null &&
messages.Count > 0)
{
writer.WritePropertyName("messages");
writer.WriteStartArray();
for (var i = 0; i < messages.Count; i++)
{
writer.WriteStartObject();
Serialise(messages[i], writer);
writer.WriteEndObject();
}
writer.WriteEndArray();
}
var bundles = bundle.Bundles;
if (bundles != null &&
bundles.Count > 0)
{
writer.WritePropertyName("bundles");
writer.WriteStartArray();
for (var i = 0; i < bundles.Count; i++)
{
writer.WriteStartObject();
Serialise(bundles[i], writer);
writer.WriteEndObject();
}
writer.WriteEndArray();
}
}
private void Builder_BundleComplete(ulong packetID, OscBundle bundle)
{
BundleComplete?.Invoke(packetID, bundle);
if (builder.Mode != OscPackageBuilderMode.PackagedAndQueued)
{
sender.Send(bundle);
return;
}
queue.Enqueue(new QueuedOscBundle()
{
PacketID = packetID, Bundle = bundle
});
if (queue.Count == 1)
{
Pump();
}
}
void EnqueueMessagesInBundle(OscBundle bundle)
{
foreach (OscPacket packet in bundle.packets)
{
if (packet is OscMessage)
{
OscMessage message = packet as OscMessage;
if (_addTimeTagsToBundledMessages)
{
message.args.Add(bundle.timeTag);
}
EnqueueMessage(message);
}
else
{
// Call recursively until all messages have been unpacked
EnqueueMessagesInBundle(packet as OscBundle);
}
}
}
public void SendMessage(SensorData sensor1Data, SensorData sensor2Data)
{
OscBundle sBundle = new OscBundle(_sourceEndPoint);
OscMessage dataOscMessage = CreateOscMessage(sensor1Data);
sBundle.Append(dataOscMessage);
dataOscMessage = CreateOscMessage(sensor2Data);
sBundle.Append(dataOscMessage);
_oscMessageQueue.Enqueue(dataOscMessage);
//MemoryStream memoryStream = new MemoryStream();
//Resources.Image.Save(memoryStream, ImageFormat.Jpeg);
//oscMessage.Append(memoryStream.ToArray());
//sSendMessages = false;
}
public static void RoundStart(int goalShape, int orientation, IntPtr goalShapeStatus)
{
//Console.WriteLine("Sending Round Start");
OscBundle bundle = new OscBundle();
bundle.AddElement(new OscElement("/roundstart"));
//send bundle
OSCSender.Send(bundle);
int[] goalShapes = new int[4*6];
Marshal.Copy(goalShapeStatus, goalShapes, 0, 4*6);
logger.AddLogWithTime("RoundStart " + numPhotos + " " + goalShape + " " + orientation, goalShapes);
}
/// <summary>
/// Sends a single packet synchronously to each destination device, with the given pairs
/// of OSC addresses and data objects</summary>
/// <param name="addressesAndData">The list of pairs</param>
/// <param name="first">The index of the first pair to send</param>
/// <param name="count">The number of pairs to send</param>
protected void SendPacket(IList<Tuple<string, object>> addressesAndData, int first, int count)
{
if (addressesAndData.Count < first + count)
return;
OscPacket packet;
if (count == 1)
{
packet = new OscMessage(ReceivingEndpoint, addressesAndData[first].Item1, addressesAndData[first].Item2);
}
else
{
var bundle = new OscBundle(ReceivingEndpoint, null);
for (int i = first; i < first + count; i++)
{
Tuple<string, object> tuple = addressesAndData[i];
var message = new OscMessage(ReceivingEndpoint, tuple.Item1, tuple.Item2);
bundle.Append(message);
}
packet = bundle;
}
foreach (IPEndPoint destination in DestinationEndpoints)
{
packet.Send(destination);
NumMessagesEverSent++;
}
}
/// <summary>
/// Raises the BundleReceivedEvent.
/// </summary>
/// <param name="bundle">The packet to include in the event arguments.</param>
private void OnBundleReceived(OscBundle bundle)
{
if (BundleReceived != null)
{
BundleReceived(this, new OscBundleReceivedEventArgs(bundle));
}
}
public static void Countdown(int timeRemaining)
{
OscBundle bundle = new OscBundle();
//HACK no countdown bundle.AddElement(new OscElement("/countdown/" + timeRemaining));
//send bundle
OSCSender.Send(bundle);
}
/// <summary>
/// Raises the <see cref="BundleReceived"/> event.
/// </summary>
/// <param name="bundle">The packet to include in the event arguments.</param>
private void OnBundleReceived(OscBundle bundle)
{
if (BundleReceived != null)
{
BundleReceived(this, new OscBundleReceivedEventArgs(bundle));
}
foreach (object value in bundle.Data)
{
if (value is OscBundle)
{
// Raise events for nested bundles
OnBundleReceived((OscBundle)value);
}
else if (value is OscMessage)
{
// Raised events for contained messages
OscMessage message = (OscMessage)value;
if (mFilterRegisteredMethods)
{
if (mRegisteredMethods.Contains(message.Address))
{
OnMessageReceived(message);
}
}
else
{
OnMessageReceived(message);
}
}
}
}
public static void HoldingFail(int player)
{
OscBundle bundle = new OscBundle();
bundle.AddElement(new OscElement("/holdfail" + player));
//send bundle
OSCSender.Send(bundle);
}
/// <summary>
/// Creates a new instance of OscBundleReceivedEventArgs
/// </summary>
/// <param name="bundle">The OscBundle received.</param>
public OscBundleReceivedEventArgs(OscBundle bundle)
{
Assert.ParamIsNotNull(bundle);
mBundle = bundle;
}
public void sendSkeletonData(Skeleton skeleton_data, int i )
{
IPEndPoint sourceEndPoint = new IPEndPoint(IPAddress.Loopback, Port);
OscBundle sBundle = new OscBundle(sourceEndPoint);
//OscMessage sMessage = new OscMessage(sourceEndPoint, "/skeleton", client);
foreach (Joint joint in skeleton_data.Joints)
{
if (this.oscCheck.IsChecked.HasValue && this.oscCheck.IsChecked.Value)
{
OscMessage oscMessage = new OscMessage(sourceEndPoint, "/skeleton", client);
oscMessage.Append(joint.JointType.ToString());
oscMessage.Append(i.ToString());
oscMessage.Append(joint.Position.X.ToString());
oscMessage.Append(joint.Position.Y.ToString());
oscMessage.Append(joint.Position.Z.ToString());
oscMessage.Send(Destination);
}
}
}
public OscClient Send(string address, bool convertDoubleToFloat, params object[] data)
{
// this.sender.WaitForAllMessagesToComplete();
log.Info("Sending to {0}", address);
if (data == null || data.Length == 0)
{
// Send empty message
var oscMessage = new OscMessage(address);
lock (lockObject)
{
this.sender.Send(oscMessage);
}
}
else
{
log.Info(" Data {0}", string.Join(" ", data));
var sendData = new object[data.Length];
for (int i = 0; i < data.Length; i++)
{
if (convertDoubleToFloat && data[i] is double)
sendData[i] = (float)((double)data[i]);
else
sendData[i] = data[i];
}
var oscMessage = new OscMessage(address, sendData);
var oscPacket = new OscBundle(0, oscMessage);
lock (lockObject)
{
this.sender.Send(oscPacket);
}
}
return this;
}
public static new bool FromBytes( byte[] data, ref int pos, int end, out OscPacket packet )
{
// Check header size
int bundleByteSize = end - pos;
if( bundleByteSize < headerByteSize ){
Debug.LogWarning( "[OSC io] OscBundle with invalid header was ignored." + Environment.NewLine );
packet = null;
return false;
}
// Check prefix
string prefixInput = Encoding.ASCII.GetString( data, pos, prefixByteSize );
if( prefixInput != prefix ){
Debug.LogWarning( "[OSC io] OscBundle with invalid header was ignored." + Environment.NewLine );
packet = null;
return false;
}
pos += prefixByteSize + 1; // + 1 to ensure bytes multiple of 4
// Get timetag
byte[] oscNtpBytes = new byte[OscTimeTag.byteSize];
Array.Copy( data, pos, oscNtpBytes, 0, OscTimeTag.byteSize );
OscTimeTag timeTag = new OscTimeTag( oscNtpBytes );
pos += OscTimeTag.byteSize;
// Create and fill bundle
packet = new OscBundle( timeTag );
OscBundle bundle = packet as OscBundle;
while( pos < end )
{
int length = BitConverter.ToInt32( data, 0 );
pos += 4;
int packetEnd = pos + length;
OscPacket subPacket;
if( pos < end && OscPacket.FromBytes( data, ref pos, packetEnd, out subPacket ) ) bundle.Add( subPacket );
}
return true;
}
// This function sends both how many skeletons are in the frame, and where they are
private void sendOSCSkeletonPositions(object sender, SkeletonFrameReadyEventArgs e)
{
sendOSCSkeletonCount();
List<Skeleton> skeletonList = kinectGroup.getMasterSkeletons();
OscBundle oscBundle = new OscBundle();
int skeletonNum = 0;
float xScale = sanitizeTextToFloat(XScaleTextBox.Text);
float xOffset = sanitizeTextToFloat(XOffsetTextBox.Text);
float yScale = sanitizeTextToFloat(YScaleTextBox.Text);
float yOffset = sanitizeTextToFloat(YOffsetTextBox.Text);
foreach (Skeleton s in skeletonList){
var oscMessage = new OscElement("/skeletonPosition",
skeletonNum,
(float)(s.Position.X * SCREEN_WIDTH_PX_M_RATIO * xScale + xOffset),
(float)(s.Position.Y * SCREEN_HEIGHT_PX_M_RATIO * yScale + yOffset),
(float)(s.Position.Z * SCREEN_WIDTH_PX_M_RATIO * xScale + xOffset),
(int)(s.TrackingId));
oscBundle.AddElement(oscMessage);
skeletonNum++;
}
oscWriter.Send(oscBundle);
}
OscBundle skeleton2DdataCoordEventArgsToOSCBundle(Skeleton2DdataCoordEventArgs e)
{
//Bundles are collections of messages
OscBundle bundle = new OscBundle(transmitter_ipendpoint);
//Messages are like packets, label with their type by method name
OscMessage message = new OscMessage(transmitter_ipendpoint, DEMO_METHOD);
//Both bundles and messages can be nested
//Must have at least one bundle and on message
//Send the whole skeleton
//First send the index
message.Append(e.index);
//Then append each point in order, x then y
int num_points = e._points.Count();
for (int i = 0; i < num_points; i++)
{
Point normalized_point = normalize_skeleton_point(e._points[i]);
message.Append((float)normalized_point.X);
message.Append((float)normalized_point.Y);
}
bundle.Append(message);
return bundle;
}
public static void ShapeCompleted(int winner, int scoreP1, int scoreP2)
{
OscBundle bundle = new OscBundle();
bundle.AddElement(new OscElement("/pwins", winner));
//send bundle
OSCSender.Send(bundle);
logger.AddLogWithTime("Win " + winner + " " + scoreP1 + " " + scoreP2);
}
public static void GameStart() //not used.
{
OscBundle bundle = new OscBundle();
bundle.AddElement(new OscElement("/gamestart"));
//send bundle
OSCSender.Send(bundle);
}
private static void SendALive(OscBundle bundle)
{
oscWriter.SendBundle(bundle);
//DisplayBundle(bundle);
}
//Return an OSC bundle for skeleton index provided
/*
OscBundle skeletonToOSCBundle(Skeleton s, int index)
{
Skeleton2DdataCoordEventArgs e = Skeleton2DDataExtract.skeletonToSkeleton2DdataCoordEventArgs(s, index);
return skeleton2DdataCoordEventArgsToOSCBundle(e);
}
*/
OscBundle skeleton2DdataCoordEventArgsToOSCBundle(Skeleton2DdataCoordEventArgs e)
{
//Bundles are collections of messages
OscBundle bundle = new OscBundle(transmitter_ipendpoint);
//Messages are like packets, label with their type by method name
OscMessage message = new OscMessage(transmitter_ipendpoint, SKELETON_METHOD);
//Both bundles and messages can be nested
//Must have at least one bundle and on message
//Send the whole skeleton
//Send packet number
message.Append(sent_bundles);
//Debug.WriteLine("Sent bundle: " + sent_bundles);
//Send the index
message.Append(e.index);
//Then append each point in order, x then y
int num_points = e._points.Count();
for (int i = 0; i < num_points; i++)
{
Point normalized_point = normalize_skeleton_point(e._points[i]);
message.Append((float)normalized_point.X);
message.Append((float)normalized_point.Y);
}
message.Append(kinect_id); //#19
//There are 19 things appended to this message. If you add more,
//you must change the numSkeletonOSCArgs in the c++ code
bundle.Append(message);
return bundle;
}
void Awake()
{
_endOfFrameBundle = new OscBundle();
if( enabled && Application.isPlaying && _openOnAwake ) Open( _port, _ipAddress );
}
public void SendMessage(SensorData sensor1Data, SensorData sensor2Data)
{
OscBundle sBundle = new OscBundle(_sourceEndPoint);
OscMessage dataOscMessage = CreateOscMessage(sensor1Data);
sBundle.Append(dataOscMessage);
dataOscMessage = CreateOscMessage(sensor2Data);
sBundle.Append(dataOscMessage);
_oscMessageQueue.Enqueue(dataOscMessage);
//MemoryStream memoryStream = new MemoryStream();
//Resources.Image.Save(memoryStream, ImageFormat.Jpeg);
//oscMessage.Append(memoryStream.ToArray());
//sSendMessages = false;
}
public static void Timeout()
{
OscBundle bundle = new OscBundle();
bundle.AddElement(new OscElement("/timeout"));
//send bundle
OSCSender.Send(bundle);
logger.AddLogWithTime("Timeout");
}
public static void ShapeStatus(int shape1, int shape2)
{
//Console.WriteLine("Got Shape Status");
OscBundle bundle = new OscBundle();
bundle.AddElement(new OscElement("/shape1/" + shape1));
bundle.AddElement(new OscElement("/shape2/" + shape2));
//send bundle
OSCSender.Send(bundle);
}
/// <summary>
/// Sends a skeleton's position and depth via OSC
/// </summary>
/// <param name="skeleton">skeleton to send</param>
private void SendSkeletonOsc(Skeleton skeleton)
{
OscBundle b = new OscBundle();
b.AddElement(GetOscJointMessage(skeleton, JointType.AnkleLeft));
b.AddElement(GetOscJointMessage(skeleton, JointType.AnkleRight));
b.AddElement(GetOscJointMessage(skeleton, JointType.ElbowLeft));
b.AddElement(GetOscJointMessage(skeleton, JointType.ElbowRight));
b.AddElement(GetOscJointMessage(skeleton, JointType.FootLeft));
b.AddElement(GetOscJointMessage(skeleton, JointType.FootRight));
b.AddElement(GetOscJointMessage(skeleton, JointType.HandLeft));
b.AddElement(GetOscJointMessage(skeleton, JointType.HandRight));
b.AddElement(GetOscJointMessage(skeleton, JointType.Head));
b.AddElement(GetOscJointMessage(skeleton, JointType.HipCenter));
b.AddElement(GetOscJointMessage(skeleton, JointType.HipLeft));
b.AddElement(GetOscJointMessage(skeleton, JointType.HipRight));
b.AddElement(GetOscJointMessage(skeleton, JointType.KneeLeft));
b.AddElement(GetOscJointMessage(skeleton, JointType.KneeRight));
b.AddElement(GetOscJointMessage(skeleton, JointType.ShoulderCenter));
b.AddElement(GetOscJointMessage(skeleton, JointType.ShoulderLeft));
b.AddElement(GetOscJointMessage(skeleton, JointType.ShoulderRight));
b.AddElement(GetOscJointMessage(skeleton, JointType.Spine));
b.AddElement(GetOscJointMessage(skeleton, JointType.WristLeft));
b.AddElement(GetOscJointMessage(skeleton, JointType.WristRight));
OSCsend.Send(b);
}
private OscBundle GetFrameBundle()
{
OscBundle bundle = new OscBundle(_ipEndPoint);
bundle.Append(GetAliveMessage());
foreach (OscMessage msg in GetCursorMessages())
{
bundle.Append(msg);
}
bundle.Append(GetSequenceMessage());
return bundle;
}
public static void SendOSCMessages(List<string> Addresses)
{
sourceEndPoint = new IPEndPoint(serverIPAddress, 53000);
OscBundle bundle = new OscBundle(sourceEndPoint);
foreach (string Address in Addresses)
bundle.Append(OSCMessage.CreateMessage(Address));
bundle.Send(sourceEndPoint);
}
