void Update()
{
// OPTIMISATION #2: Cache outgoing messages.
// Use the cached message for sending.
floatMessage.args[0] = Random.value;
// OPTIMISATION #3: Use blobs for large arrays.
// If you are sending large arrays, the you can compress the message
// sending them as blobs. By doing this you avoid sending a type tag for every
// element in the array. See the methods IntArrayToBlob and BlobToIntArray.
int[] intArray = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
byte[] blob = IntArrayToBlob(intArray);
blobMessage.args[0] = blob;
// OPTIMISATION #1: Bundle your messages
// Sending one bundle instead of seperate messages is more efficient.
bundle.Add(floatMessage);
bundle.Add(blobMessage);
oscOut.Send(bundle);
bundle.Clear();
// Update labels.
if (oscOut.isOpen)
{
sendFloatLabel.text = floatMessage.args[0].ToString();
string intArrayString = "";
foreach (int i in intArray)
{
intArrayString += i + " ";
}
sendBlobLabel.text = intArrayString;
}
}
IEnumerator SendBundleOnEndOfFrame()
{
yield return(new WaitForEndOfFrame());
_endOfFrameBundle.timeTag.time = DateTime.Now;
Send(_endOfFrameBundle);
_endOfFrameBundle.Clear();
}
public static OscBundle GetBundle()
{
if (_bundles.Count > 0)
{
OscBundle bundle = _bundles.Pop();
bundle.Clear();
return(bundle);
}
return(new OscBundle());
}
/// <summary>
/// Send an OscMessage or OscBundle. Data is serialized and no reference is stored, so you can safely
/// change values and send packet immediately again.
/// Returns success status.
/// </summary>
public bool Send( OscPacket packet )
{
if( !isOpen ) return false;
// On any message.
if( _onAnyMessage != null ) InvokeAnyMessageEventRecursively( packet );
// Individual messages are always send in bundles at end of frame.
if( packet is OscMessage ){
_endOfFrameBuffer.Add( packet as OscMessage );
return true; // Assume success.
}
// Split bundle case.
if( packet.Size() > _udpBufferSize ){
ExtractMessages( packet, _tempMessageQueue );
int bundleByteCount = OscConst.bundleHeaderSize;
OscBundle splitBundle = OscPool.GetBundle();
while( _tempMessageQueue.Count > 0 )
{
OscMessage message = _tempMessageQueue.Dequeue();
// Check if message is too big.
int messageSize = message.Size() + FourByteOscData.byteCount; // Bundle stores size of each message in a 4 byte integer.
if( messageSize > _udpBufferSize ){
StringBuilder sb = OscDebug.BuildText( this );
sb.Append( "Failed to send message. Message size at " ); sb.Append( messageSize );
sb.Append( " bytes exceeds udp buffer size at " ); sb.Append( _udpBufferSize );
sb.Append( " bytes. Try increasing the buffer size.'\n" );
Debug.LogWarning( sb.ToString() );
return false;
}
// If bundle is full, send it and prepare for new bundle.
if( bundleByteCount + messageSize > _udpBufferSize ) {
if( !Send( splitBundle ) ) return false;
bundleByteCount = OscConst.bundleHeaderSize;
splitBundle.Clear();
}
splitBundle.packets.Add( message );
bundleByteCount += messageSize;
}
if( splitBundle.packets.Count > 0 && !Send( splitBundle ) ) return false;
OscPool.Recycle( splitBundle );
return true;
}
// Try to pack the message.
int index = 0;
if( !packet.TryWriteTo( _cache, ref index ) ) return false;
//Debug.Log( $"Sending byte count {index}" );
// Send data!
return TrySendCache( index );
}
/// <summary>
/// Send an OscMessage or OscBundle. Data is serialized and no reference is stored, so you can safely
/// change values and send packet immediately again.
/// Returns success status.
/// </summary>
public bool Send(OscPacket packet)
{
if (!isOpen)
{
return(false);
}
int index = 0;
// On any message.
if (_onAnyMessage != null)
{
InvokeAnyMessageEventRecursively(packet);
}
// Adapt buffer size.
if (_sendBuffer == null || _sendBuffer.Length != _udpBufferSize)
{
_sendBuffer = new byte[_udpBufferSize];
}
// Handle user messages.
if (packet is OscMessage)
{
if (_bundleMessagesAutomatically)
{
// Collect to be bundled and send by end of the Unity frame.
_autoBundleMessageBuffer.Add(packet as OscMessage);
return(true); // Assume success.
}
else
{
// Add to cache and send immediately.
OscMessage message = packet as OscMessage;
message.TryWriteTo(_sendBuffer, ref index);
bool success = TrySendBuffer(index);
if (success)
{
_messageCountThisFrame++;
}
return(success);
}
}
// Handle user bundles. Bundles provided by the user are send immediately. If too big, they are split into more bundles.
OscBundle bundle = packet as OscBundle;
if (bundle.Size() > _udpBufferSize)
{
ExtractMessages(packet, _userBundleTempMessages);
int bundleByteCount = OscConst.bundleHeaderSize;
OscBundle splitBundle = OscPool.GetBundle();
while (_userBundleTempMessages.Count > 0)
{
OscMessage message = _userBundleTempMessages.Dequeue();
// Check if message is too big.
int messageSize = message.Size() + FourByteOscData.byteCount; // Bundle stores size of each message in a 4 byte integer.
if (messageSize > _udpBufferSize)
{
if (OscGlobals.logWarnings)
{
StringBuilder sb = OscDebug.BuildText(this);
sb.Append("Failed to send message. Message size at "); sb.Append(messageSize);
sb.Append(" bytes exceeds udp buffer size at "); sb.Append(_udpBufferSize);
sb.Append(" bytes. Try increasing the buffer size.'\n");
Debug.LogWarning(sb.ToString());
}
return(false);
}
// If bundle is full, send it and prepare for new bundle.
if (bundleByteCount + messageSize > _udpBufferSize)
{
if (!Send(splitBundle))
{
return(false);
}
bundleByteCount = OscConst.bundleHeaderSize;
splitBundle.Clear();
}
splitBundle.packets.Add(message);
bundleByteCount += messageSize;
}
if (splitBundle.packets.Count > 0 && !Send(splitBundle))
{
return(false);
}
OscPool.Recycle(splitBundle);
return(true);
}
// Try to pack the message.
if (!bundle.TryWriteTo(_sendBuffer, ref index))
{
return(false);
}
_messageCountThisFrame += bundle.packets.Count;
// Send data!
return(TrySendBuffer(index));
}