Listening for OSC data

Hi - I’m using Kyle McDonald’s faceshift OSC (https://github.com/kylemcdonald/ofxFaceShift/tree/master/example-osc) to broadcast OSC data from the faceshift application. I’m now trying to write an application which receives that data (in Unity, not oF). I’m basing my code off of this:

https://github.com/jorgegarcia/UnityOSC

The client is set up in openFrameworks to broadcast OSC data on port 8338 (of localhost). How do I change my code in Unity below to receive that data? Note that the code looks long, but really the only things that I think need adjustment are the init function of OSCFaceshift.cs, or the init function of OSCHandler.cs:

OSCFaceshift.cs - (The code I wrote)

  
  
using UnityEngine;  
using System;  
using System.Collections;  
using System.Collections.Generic;  
using System.Text;  
using UnityOSC;  
  
public class OSCFaceshift : MonoBehaviour {  
    private Dictionary<string, ServerLog> servers;  
  
    // Script initialization  
    void Start() {    
        OSCHandler.Instance.Init();   
        servers = new Dictionary<string, ServerLog>();  
    }  
  
    void Update() {  
  
        OSCHandler.Instance.UpdateLogs();  
        servers = OSCHandler.Instance.Servers;  
  
        foreach(KeyValuePair<string, ServerLog> item in servers)  
        {  
            // If we have received at least one packet,  
            // show the last received from the log in the Debug console  
            if(item.Value.log.Count > 0)   
            {  
                int lastPacketIndex = item.Value.packets.Count - 1;  
  
                UnityEngine.Debug.Log(String.Format("SERVER: {0} ADDRESS: {1} VALUE 0: {2}",   
                item.Key, // Server name  
                item.Value.packets[lastPacketIndex].Address, // OSC address  
                item.Value.packets[lastPacketIndex].Data[0].ToString())); //First data value  
            }  
        }  
  
        if (Input.GetButtonDown("Fire1") ){  
            OSCHandler.Instance.SendMessageToClient("FaceClient", "test/alive", "testing");  
        }  
  
    }  
}  
  

OSC Handler.cs - //The code I downloaded to try and bring OSC into Unity

  
  
//  
//    UnityOSC - Open Sound Control interface for the Unity3d game engine  
//  
//    Copyright (c) 2011 Jorge Garcia <info@jorgegarciamartin.com>  
//  
//    This library is free software; you can redistribute it and/or  
//    modify it under the terms of the GNU Lesser General Public  
//    License as published by the Free Software Foundation; either  
//    version 2.1 of the License, or (at your option) any later version.  
//  
//    This library is distributed in the hope that it will be useful,  
//    but WITHOUT ANY WARRANTY; without even the implied warranty of  
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU  
//    Lesser General Public License for more details.  
//  
//    You should have received a copy of the GNU Lesser General Public  
//    License along with this library; if not, see <[http://www.gnu.org/licenses/>.](http://www.gnu.org/licenses/>.)  
//  
/// Inspired by [http://www.unifycommunity.com/wiki/index.php?title=AManagerClass](http://www.unifycommunity.com/wiki/index.php?title=AManagerClass)  
  
using System;  
using System.Net;  
using System.Collections.Generic;  
  
using UnityEngine;  
using UnityOSC;  
  
/// <summary>  
/// Models a log of a server composed by an OSCServer, a List of OSCPacket and a List of  
/// strings that represent the current messages in the log.  
/// </summary>  
public struct ServerLog  
{  
    public OSCServer server;  
    public List<OSCPacket> packets;  
    public List<string> log;  
}  
  
/// <summary>  
/// Models a log of a client composed by an OSCClient, a List of OSCMessage and a List of  
/// strings that represent the current messages in the log.  
/// </summary>  
public struct ClientLog  
{  
    public OSCClient client;  
    public List<OSCMessage> messages;  
    public List<string> log;  
}  
  
/// <summary>  
/// Handles all the OSC servers and clients of the current Unity game/application.  
/// Tracks incoming and outgoing messages.  
/// </summary>  
public class OSCHandler : MonoBehaviour  
{  
    #region Singleton Constructors  
    static OSCHandler()  
    {  
    }  
  
    OSCHandler()  
    {  
    }  
  
    public static OSCHandler Instance   
    {  
        get   
        {  
            if (_instance == null)   
            {  
                _instance = new GameObject ("OSCHandler").AddComponent<OSCHandler>();  
            }  
  
            return _instance;  
        }  
    }  
    #endregion  
  
    #region Member Variables  
    private static OSCHandler _instance = null;  
    private Dictionary<string, ClientLog> _clients = new Dictionary<string, ClientLog>();  
    private Dictionary<string, ServerLog> _servers = new Dictionary<string, ServerLog>();  
  
    private const int _loglength = 25;  
    #endregion  
  
    /// <summary>  
    /// Initializes the OSC Handler.  
    /// Here you can create the OSC servers and clientes.  
    /// </summary>  
    public void Init()  
    {  
        //Initialize OSC clients (transmitters)  
        CreateClient("FaceClient", IPAddress.Parse("127.0.0.1"), 33433);  
  
        //Initialize OSC servers (listeners)  
        //Example:  
  
        CreateServer("FaceServer", 8338); //MH - do we need to create a server? The server is Unity itself...     
    }  
  
    #region Properties  
    public Dictionary<string, ClientLog> Clients  
    {  
        get  
        {  
            return _clients;  
        }  
    }  
  
    public Dictionary<string, ServerLog> Servers  
    {  
        get  
        {  
            return _servers;  
        }  
    }  
    #endregion  
  
    #region Methods  
  
    /// <summary>  
    /// Ensure that the instance is destroyed when the game is stopped in the Unity editor  
    /// Close all the OSC clients and servers  
    /// </summary>  
    void OnApplicationQuit()   
    {  
        foreach(KeyValuePair<string,ClientLog> pair in _clients)  
        {  
            pair.Value.client.Close();  
        }  
  
        foreach(KeyValuePair<string,ServerLog> pair in _servers)  
        {  
            pair.Value.server.Close();  
        }  
  
        _instance = null;  
    }  
  
    /// <summary>  
    /// Creates an OSC Client (sends OSC messages) given an outgoing port and address.  
    /// </summary>  
    /// <param name="clientId">  
    /// A <see cref="System.String"/>  
    /// </param>  
    /// <param name="destination">  
    /// A <see cref="IPAddress"/>  
    /// </param>  
    /// <param name="port">  
    /// A <see cref="System.Int32"/>  
    /// </param>  
    public void CreateClient(string clientId, IPAddress destination, int port)  
    {  
        ClientLog clientitem = new ClientLog();  
        clientitem.client = new OSCClient(destination, port);  
        clientitem.log = new List<string>();  
        clientitem.messages = new List<OSCMessage>();  
  
        _clients.Add(clientId, clientitem);  
  
        // Send test message  
        string testaddress = "/test/alive/";  
        OSCMessage message = new OSCMessage(testaddress, destination.ToString());  
        message.Append(port); message.Append("OK");  
  
        _clients[clientId].log.Add(String.Concat(DateTime.UtcNow.ToString(),".",  
                                                 FormatMilliseconds(DateTime.Now.Millisecond), " : ",  
                                                 testaddress," ", DataToString(message.Data)));  
        _clients[clientId].messages.Add(message);  
  
        _clients[clientId].client.Send(message);  
    }  
  
    /// <summary>  
    /// Creates an OSC Server (listens to upcoming OSC messages) given an incoming port.  
    /// </summary>  
    /// <param name="serverId">  
    /// A <see cref="System.String"/>  
    /// </param>  
    /// <param name="port">  
    /// A <see cref="System.Int32"/>  
    /// </param>  
    public void CreateServer(string serverId, int port)  
    {  
        //Debug.Log("Create Server");  
        ServerLog serveritem = new ServerLog();  
        serveritem.server = new OSCServer(port);  
        serveritem.log = new List<string>();  
        serveritem.packets = new List<OSCPacket>();  
  
        _servers.Add(serverId, serveritem);  
    }  
  
    /// <summary>  
    /// Sends an OSC message to a specified client, given its clientId (defined at the OSC client construction),  
    /// OSC address and a single value. Also updates the client log.  
    /// </summary>  
    /// <param name="clientId">  
    /// A <see cref="System.String"/>  
    /// </param>  
    /// <param name="address">  
    /// A <see cref="System.String"/>  
    /// </param>  
    /// <param name="value">  
    /// A <see cref="T"/>  
    /// </param>  
    public void SendMessageToClient<T>(string clientId, string address, T value)  
    {  
        //Debug.Log("SMTC");  
        List<object> temp = new List<object>();  
        temp.Add(value);  
  
        SendMessageToClient(clientId, address, temp);  
    }  
  
    /// <summary>  
    /// Sends an OSC message to a specified client, given its clientId (defined at the OSC client construction),  
    /// OSC address and a list of values. Also updates the client log.  
    /// </summary>  
    /// <param name="clientId">  
    /// A <see cref="System.String"/>  
    /// </param>  
    /// <param name="address">  
    /// A <see cref="System.String"/>  
    /// </param>  
    /// <param name="values">  
    /// A <see cref="List<T>"/>  
    /// </param>  
    public void SendMessageToClient<T>(string clientId, string address, List<T> values)  
    {     
  
        if(_clients.ContainsKey(clientId))  
        {  
            OSCMessage message = new OSCMessage(address);  
  
            foreach(T msgvalue in values)  
            {  
                message.Append(msgvalue);  
                Debug.Log(msgvalue);  
            }  
  
            if(_clients[clientId].log.Count < _loglength)  
            {  
                _clients[clientId].log.Add(String.Concat(DateTime.UtcNow.ToString(),".",  
                                                         FormatMilliseconds(DateTime.Now.Millisecond),  
                                                         " : ", address, " ", DataToString(message.Data)));  
                _clients[clientId].messages.Add(message);  
            }  
            else  
            {  
                _clients[clientId].log.RemoveAt(0);  
                _clients[clientId].messages.RemoveAt(0);  
  
                _clients[clientId].log.Add(String.Concat(DateTime.UtcNow.ToString(),".",  
                                                         FormatMilliseconds(DateTime.Now.Millisecond),  
                                                         " : ", address, " ", DataToString(message.Data)));  
                _clients[clientId].messages.Add(message);  
            }  
  
            _clients[clientId].client.Send(message);  
        }  
        else  
        {  
            Debug.LogError(string.Format("Can't send OSC messages to {0}. Client doesn't exist.", clientId));  
        }  
    }  
  
    /// <summary>  
    /// Updates clients and servers logs.  
    /// </summary>  
    public void UpdateLogs()  
    {  
        foreach(KeyValuePair<string,ServerLog> pair in _servers)  
        {  
            if(_servers[pair.Key].server.LastReceivedPacket != null)  
            {  
                //Initialization for the first packet received  
                if(_servers[pair.Key].log.Count == 0)  
                {     
                    _servers[pair.Key].packets.Add(_servers[pair.Key].server.LastReceivedPacket);  
  
                    _servers[pair.Key].log.Add(String.Concat(DateTime.UtcNow.ToString(), ".",  
                                                             FormatMilliseconds(DateTime.Now.Millisecond)," : ",  
                                                             _servers[pair.Key].server.LastReceivedPacket.Address," ",  
                                                             DataToString(_servers[pair.Key].server.LastReceivedPacket.Data)));  
                    break;  
                }  
  
                if(_servers[pair.Key].server.LastReceivedPacket.TimeStamp  
                   != _servers[pair.Key].packets[_servers[pair.Key].packets.Count - 1].TimeStamp)  
                {     
                    if(_servers[pair.Key].log.Count > _loglength - 1)  
                    {  
                        _servers[pair.Key].log.RemoveAt(0);  
                        _servers[pair.Key].packets.RemoveAt(0);  
                    }  
  
                    _servers[pair.Key].packets.Add(_servers[pair.Key].server.LastReceivedPacket);  
  
                    _servers[pair.Key].log.Add(String.Concat(DateTime.UtcNow.ToString(), ".",  
                                                             FormatMilliseconds(DateTime.Now.Millisecond)," : ",  
                                                             _servers[pair.Key].server.LastReceivedPacket.Address," ",  
                                                             DataToString(_servers[pair.Key].server.LastReceivedPacket.Data)));  
                }  
            }  
        }  
    }  
  
    /// <summary>  
    /// Converts a collection of object values to a concatenated string.  
    /// </summary>  
    /// <param name="data">  
    /// A <see cref="List<System.Object>"/>  
    /// </param>  
    /// <returns>  
    /// A <see cref="System.String"/>  
    /// </returns>  
    private string DataToString(List<object> data)  
    {  
        string buffer = "";  
  
        for(int i = 0; i < data.Count; i++)  
        {  
            buffer += data[i].ToString() + " ";  
        }  
  
        buffer += "\n";  
  
        return buffer;  
    }  
  
    /// <summary>  
    /// Formats a milliseconds number to a 000 format. E.g. given 50, it outputs 050. Given 5, it outputs 005  
    /// </summary>  
    /// <param name="milliseconds">  
    /// A <see cref="System.Int32"/>  
    /// </param>  
    /// <returns>  
    /// A <see cref="System.String"/>  
    /// </returns>  
    private string FormatMilliseconds(int milliseconds)  
    {     
        if(milliseconds < 100)  
        {  
            if(milliseconds < 10)  
                return String.Concat("00",milliseconds.ToString());  
  
            return String.Concat("0",milliseconds.ToString());  
        }  
  
        return milliseconds.ToString();  
    }  
  
    #endregion  
}