void ofxRemoteUIClient::fillPresetListFromMessage(ofxOscMessage m){
int n = m.getNumArgs();
//check if server has no presets at all
if (m.getNumArgs() == 1){
if(m.getArgAsString(0) == OFXREMOTEUI_NO_PRESETS){ //if no prests, server sends only one with this value
//we know there's no presets
}
}
presetNames.clear();
for(int i = 0; i < n; i++){
presetNames.push_back( m.getArgAsString(i));
}
}
void ramNodeArray::updateWithOscMessage(const ofxOscMessage &m)
{
const int nNodes = m.getArgAsInt32(1);
for (int i = 0; i < nNodes; i++)
{
const string name = m.getArgAsString(i * 8 + 0 + 2);
const float vx = m.getArgAsFloat(i * 8 + 1 + 2);
const float vy = m.getArgAsFloat(i * 8 + 2 + 2);
const float vz = m.getArgAsFloat(i * 8 + 3 + 2);
const float angle = m.getArgAsFloat(i * 8 + 4 + 2);
const float ax = m.getArgAsFloat(i * 8 + 5 + 2);
const float ay = m.getArgAsFloat(i * 8 + 6 + 2);
const float az = m.getArgAsFloat(i * 8 + 7 + 2);
const ofVec3f axis(ax, ay, az);
const ofVec3f vec(vx, vy, vz);
const ofQuaternion quat(angle, axis);
ramNode &node = getNode(i);
node.node_id = i;
node.name = isActor() ? getJointName(i) : "Node " + ofToString(i);
node.setGlobalPosition(vec);
node.setGlobalOrientation(quat);
node.accelerometer.update(vec, quat);
}
last_timestamp = current_timestamp;
current_timestamp = m.getArgAsFloat(2 + nNodes * 8);
last_update_client_time = ofGetElapsedTimef();
}
void Ableton::getDeviceList(ofxOscMessage &m)
{
int numArgs = m.getNumArgs();
int track = m.getArgAsInt32(0);
if (tracks.count(track) == 0)
{
AbletonTrack *newTrack = new AbletonTrack("track "+ofToString(track), track, numScenes, &sender);
tracks[track] = newTrack;
newTrack->getControl()->setCollapsible(true);
if (track == 0) {
control.attachWidget(newTrack->getControl());
}
else {
tracks[track-1]->getControl()->attachWidget(newTrack->getControl());
}
}
for (int i = 1; i < numArgs; i+=2)
{
int device = m.getArgAsInt32(i);
string name = m.getArgAsString(i+1);
if (tracks[track]->getDevices().count(device) == 0)
{
AbletonDevice *newDevice = new AbletonDevice(name, track, device, &sender);
tracks[track]->addDevice(device, newDevice);
}
requestDeviceParameters(track, device);
requestDeviceParametersRange(track, device);
}
}
void testApp::setOscDebugMessage(ofxOscMessage message)
{
std::stringstream stream;
stream << "OSC messages";
if (!showOscDebugPosition)
{
stream << " (Not showing position messages)";
}
stream << " :\n";
stream << "[address]: " << message.getAddress() << ", ";
for (int i = 0; i < message.getNumArgs(); ++i) {
stream << "[" << (i+1) << "]: ";
if (message.getArgType(i) == OFXOSC_TYPE_INT32) {
stream << message.getArgAsInt32(i);
}
else if (message.getArgType(i) == OFXOSC_TYPE_STRING) {
stream << message.getArgAsString(i);
}
else if (message.getArgType(i) == OFXOSC_TYPE_FLOAT) {
stream << message.getArgAsFloat(i);
}
if (i != message.getNumArgs()-1) {stream << ", ";};
}
stream << ", time: ";
stream << ofGetElapsedTimef();
m_debugMessage = stream.str();
}
//----------
void OscManager::oscReceiveProcessMessage(string address, ofxOscMessage &msg) {
ParameterBase::Type type = inputTrackers[address]->getType();
if (type == ParameterBase::BOOL) {
((Parameter<bool> *) inputTrackers[address]->parameter)->set(msg.getArgAsInt32(0)==1);
}
else if (type == ParameterBase::STRING) {
((Parameter<string> *) inputTrackers[address]->parameter)->set(msg.getArgAsString(0));
}
else if (type == ParameterBase::INT) {
((Parameter<int> *) inputTrackers[address]->parameter)->set((int) msg.getArgAsFloat(0));
}
else if (type == ParameterBase::FLOAT) {
((Parameter<float> *) inputTrackers[address]->parameter)->set(msg.getArgAsFloat(0));
}
else if (type == ParameterBase::VEC2F) {
((Parameter<ofVec2f> *) inputTrackers[address]->parameter)->set(ofVec2f(msg.getArgAsFloat(0), msg.getArgAsFloat(1)));
}
else if (type == ParameterBase::VEC3F) {
((Parameter<ofVec3f> *) inputTrackers[address]->parameter)->set(ofVec3f(msg.getArgAsFloat(0), msg.getArgAsFloat(1), msg.getArgAsFloat(2)));
}
else if (type == ParameterBase::VEC4F) {
((Parameter<ofVec4f> *) inputTrackers[address]->parameter)->set(ofVec4f(msg.getArgAsFloat(0), msg.getArgAsFloat(1), msg.getArgAsFloat(2), msg.getArgAsFloat(3)));
}
}
string ofApp::getMsgContent(ofxOscMessage m){
bool DISPLAY_ALL = false;
string msg_string = "";
int iTotalArg = m.getNumArgs(), i = -1;
if (DISPLAY_ALL){
msg_string += ", port: " + m.getAddress();
}
if (++i < iTotalArg && DISPLAY_ALL) msg_string += "NAME: " + m.getArgAsString(i);
if (++i < iTotalArg) msg_string += " " + m.getArgAsString(i); //STATUS
if (++i < iTotalArg) msg_string += " " + m.getArgAsString(i); //FILE
if (++i < iTotalArg && DISPLAY_ALL) msg_string += ", POSITION: " + ofToString(m.getArgAsInt(i));
if (++i < iTotalArg && DISPLAY_ALL) msg_string += ", DURATION: " + ofToString(m.getArgAsInt(i));
if (++i < iTotalArg) msg_string += ", LOOPING: " + ofToString(m.getArgAsInt(i));
if (++i < iTotalArg && DISPLAY_ALL) msg_string += ", VOLUME: " + ofToString(m.getArgAsInt(i));
if (++i < iTotalArg && DISPLAY_ALL) msg_string += ", MUTE: " + m.getArgAsString(i);
if (++i < iTotalArg && DISPLAY_ALL) msg_string += ", ZOOM: " + ofToString(m.getArgAsInt(i));
if (++i < iTotalArg && DISPLAY_ALL) msg_string += ", BLUR: " + ofToString(m.getArgAsInt(i));
return msg_string;
}
string messenger::dumpOSC(ofxOscMessage m) {
string msg_string;
msg_string = m.getAddress();
for (int i=0; i<m.getNumArgs(); i++ ) {
msg_string += " ";
if(m.getArgType(i) == OFXOSC_TYPE_INT32)
msg_string += ofToString( m.getArgAsInt32(i));
else if(m.getArgType(i) == OFXOSC_TYPE_FLOAT)
msg_string += ofToString( m.getArgAsFloat(i));
else if(m.getArgType(i) == OFXOSC_TYPE_STRING)
msg_string += m.getArgAsString(i);
}
return msg_string;
}
void ofApp::dumpOSC(ofxOscMessage m) {
string msgString;
msgString = m.getAddress();
for (int i=0; i<m.getNumArgs(); i++){
msgString += " ";
if(m.getArgType(i) == OFXOSC_TYPE_INT32)
msgString += ofToString(m.getArgAsInt32(i));
else if(m.getArgType(i) == OFXOSC_TYPE_FLOAT)
msgString += ofToString(m.getArgAsFloat(i));
else if(m.getArgType(i) == OFXOSC_TYPE_STRING)
msgString += m.getArgAsString(i);
}
cout << msgString << endl;
}
string ofApp::oscMsgToString(int num, string adr, ofxOscMessage msg) {
string res= adr;
for(int i= 0; i<num; i++) {
res= res+" ";
if(msg.getArgType(i)==OFXOSC_TYPE_INT32) {
res= res+ofToString(msg.getArgAsInt32(i));
} else if(msg.getArgType(i)==OFXOSC_TYPE_FLOAT) {
res= res+ofToString(msg.getArgAsFloat(i));
} else if(msg.getArgType(i)==OFXOSC_TYPE_STRING) {
res= res+msg.getArgAsString(i);
}
}
return res;
}
void ofApp::confirmMessage(ofxOscMessage m){
//figure out which pi
string sIp = m.getRemoteIp();
string msgContent = getMsgContent(m);
int iCurPi = -1;
if (hasEnding(sIp, pi1_ip)){
iCurPi = 0;
m_bOscConfirmations[0] = true;
logMsg("got msg from 1: " + msgContent);
}
else if (hasEnding(sIp, pi2_ip)){
iCurPi = 1;
m_bOscConfirmations[1] = true;
logMsg("got msg from 2: " + msgContent);
}
else if (hasEnding(sIp, pi3_ip)){
iCurPi = 2;
m_bOscConfirmations[2] = true;
logMsg("got msg from 3: " + msgContent);
}
else if (hasEnding(sIp, pi4_ip)){
iCurPi = 3;
m_bOscConfirmations[3] = true;
logMsg("got msg from 4: " + msgContent);
} else {
logMsg("got msg from UNKNOWN " + sIp + ": " + msgContent);
}
//update corresponding status
string sCurStatus = "";
int iCurArg = 1;
string sStatus = m.getArgAsString(iCurArg++);
string sFile = m.getArgAsString(iCurArg++);
iCurArg += 2;
bool bLoop = m.getArgAsInt(iCurArg++);
if (hasEnding(sStatus, "stoped")){
sCurStatus += "Stopped";
} else {
if (bLoop){
sCurStatus += "Loop\t";
} else {
sCurStatus += "Play\t";
}
sCurStatus += sFile;
}
m_sRpiStatuses[iCurPi] = sCurStatus;
}
void ramActorManager::updateWithOscMessage(const ofxOscMessage &m)
{
if (isFreezed()) return;
const std::string addr = m.getAddress();
const std::string name = m.getArgAsString(0);
if (addr == RAM_OSC_ADDR_ACTOR)
{
if (!nodearrays.hasKey(name))
{
ramActor o;
o.setType(RAM_NODEARRAY_TYPE_ACTOR);
o.setName(name);
o.updateWithOscMessage(m);
nodearrays.set(name, o);
ofNotifyEvent(actorSetup, o);
}
else
{
ramActor &o = (ramActor &)nodearrays[name];
o.updateWithOscMessage(m);
}
}
else if (addr == RAM_OSC_ADDR_RIGID_BODY)
{
if (!nodearrays.hasKey(name))
{
ramRigidBody o;
o.setType(RAM_NODEARRAY_TYPE_RIGIDBODY);
o.setName(name);
o.updateWithOscMessage(m);
nodearrays.set(name, o);
ofNotifyEvent(rigidSetup, o);
}
else
{
ramRigidBody &o = (ramRigidBody &)nodearrays[name];
o.updateWithOscMessage(m);
}
}
else assert(false);
}
void ofxOscSender::appendMessage( ofxOscMessage& message, osc::OutboundPacketStream& p )
{
p << osc::BeginMessage( message.getAddress().c_str() );
for ( int i=0; i< message.getNumArgs(); ++i )
{
if ( message.getArgType(i) == OFXOSC_TYPE_INT32 )
p << message.getArgAsInt32( i );
else if ( message.getArgType( i ) == OFXOSC_TYPE_FLOAT )
p << message.getArgAsFloat( i );
else if ( message.getArgType( i ) == OFXOSC_TYPE_STRING )
p << message.getArgAsString( i ).c_str();
else
{
assert( false && "bad argument type" );
}
}
p << osc::EndMessage;
}
string ofApp::getOscMsgAsString(ofxOscMessage m){
// method from the client server ofxOsc example !
string msg_string;
msg_string ="";
for(int i = 0; i < m.getNumArgs(); i++){
// get the argument type
if(m.getArgType(i) == OFXOSC_TYPE_INT32){
msg_string += ofToString(m.getArgAsInt32(i));
}
else if(m.getArgType(i) == OFXOSC_TYPE_FLOAT){
msg_string += ofToString(m.getArgAsFloat(i));
}
else if(m.getArgType(i) == OFXOSC_TYPE_STRING){
msg_string += m.getArgAsString(i);
}
}
return msg_string;
}
void ofxDuration::parseInfoMessage(const ofxOscMessage& m){
ofLogVerbose("ofxDuration::parseInfoMessage") << "Received track information from Duration, #args " << m.getNumArgs();
tracks.clear();
trackNames.clear();
//pairs of two strings per track, name and type
for(int i = 0; i < m.getNumArgs()-1; i+=2){
if(m.getArgType(i ) == OFXOSC_TYPE_STRING &&
m.getArgType(i+1) == OFXOSC_TYPE_STRING)
{
string trackType = m.getArgAsString(i );
string trackName = m.getArgAsString(i+1);
ofxDurationTrack t;
t.type = trackType;
t.name = trackName;
t.lastUpdatedTime = ofGetElapsedTimef();
ofLogVerbose("ofxDuration::parseInfoMessage") << "Adding track " << t.type << " : " << t.name;
if(trackType == "Curves" || trackType == "LFO"){
//consume two more args for min and max
if(i+3 < m.getNumArgs() &&
m.getArgType(i+2) == OFXOSC_TYPE_FLOAT &&
m.getArgType(i+3) == OFXOSC_TYPE_FLOAT)
{
t.range = ofRange(m.getArgAsFloat(i+2), m.getArgAsFloat(i+3));
ofLogVerbose("ofxDuration::parseInfoMessage") << " track range is " << t.range;
i+=2;
}
}
//only add unique names
if(tracks.find(t.name) == tracks.end()){
trackNames.push_back(t.name);
tracks[t.name] = t;
}
else{
ofLogNotice("ofxDuration::parseInfoMessage") << "Duplicate track name received: " << t.name;
}
}
}
ofLogVerbose("ofxDuration::parseInfoMessage") << "Created " << tracks.size() << " tracks";
}
//--------------------------------------------------------------
void oscReceiver::setParameterValue(ofAbstractParameter& param, ofxOscMessage& msg, int oscArgIndex)
{
ofAbstractParameter* p = ¶m;
if(p->type()==typeid(ofParameter<int>).name() && msg.getArgType(oscArgIndex)==OFXOSC_TYPE_INT32)
{
p->cast<int>() = msg.getArgAsInt32(oscArgIndex);
}
else if(p->type()==typeid(ofParameter<float>).name() && msg.getArgType(oscArgIndex)==OFXOSC_TYPE_FLOAT)
{
p->cast<float>() = msg.getArgAsFloat(oscArgIndex);
}else if(p->type()==typeid(ofParameter<bool>).name() && msg.getArgType(oscArgIndex)==OFXOSC_TYPE_INT32)
{
p->cast<bool>() = msg.getArgAsInt32(oscArgIndex);
}else if(msg.getArgType(oscArgIndex)==OFXOSC_TYPE_STRING)
{
p->fromString(msg.getArgAsString(oscArgIndex));
}
}
void ofxGstRTPServer::appendMessage( ofxOscMessage& message, osc::OutboundPacketStream& p )
{
p << osc::BeginMessage( message.getAddress().c_str() );
for ( int i=0; i< message.getNumArgs(); ++i )
{
if ( message.getArgType(i) == OFXOSC_TYPE_INT32 )
p << message.getArgAsInt32( i );
else if ( message.getArgType(i) == OFXOSC_TYPE_INT64 )
p << (osc::int64)message.getArgAsInt64( i );
else if ( message.getArgType( i ) == OFXOSC_TYPE_FLOAT )
p << message.getArgAsFloat( i );
else if ( message.getArgType( i ) == OFXOSC_TYPE_STRING )
p << message.getArgAsString( i ).c_str();
else
{
ofLogError("ofxOscSender") << "appendMessage(): bad argument type " << message.getArgType( i );
}
//cout << i << ": " << p.Size() << endl;
}
p << osc::EndMessage;
}
//--------------------------------------------------------------
// OSCメッセージをコンソールに出力する関数
//
string ofApp::dumpOSC(ofxOscMessage m) {
string str = m.getAddress();
for (int i=0; i<m.getNumArgs(); i++ ) {
str += " ";
switch (m.getArgType(i)) {
case OFXOSC_TYPE_INT32:
str += ofToString( m.getArgAsInt32(i));
break;
case OFXOSC_TYPE_FLOAT:
str += ofToString( m.getArgAsFloat(i));
break;
case OFXOSC_TYPE_STRING:
str += m.getArgAsString(i);
break;
default:
break;
}
}
cout << str << endl;
return str;
}
void ofApp::appendMessage( ofxOscMessage& message, osc::OutboundPacketStream& p )
{
p << osc::BeginMessage( message.getAddress().c_str() );
for ( int i=0; i< message.getNumArgs(); ++i )
{
if ( message.getArgType(i) == OFXOSC_TYPE_INT32 )
p << message.getArgAsInt32( i );
else if ( message.getArgType(i) == OFXOSC_TYPE_INT64 )
p << (osc::int64)message.getArgAsInt64( i );
else if ( message.getArgType( i ) == OFXOSC_TYPE_FLOAT )
p << message.getArgAsFloat( i );
else if ( message.getArgType( i ) == OFXOSC_TYPE_DOUBLE )
p << message.getArgAsDouble( i );
else if ( message.getArgType( i ) == OFXOSC_TYPE_STRING || message.getArgType( i ) == OFXOSC_TYPE_SYMBOL)
p << message.getArgAsString( i ).c_str();
else if ( message.getArgType( i ) == OFXOSC_TYPE_CHAR )
p << message.getArgAsChar( i );
else if ( message.getArgType( i ) == OFXOSC_TYPE_MIDI_MESSAGE )
p << message.getArgAsMidiMessage( i );
else if ( message.getArgType( i ) == OFXOSC_TYPE_TRUE || message.getArgType( i ) == OFXOSC_TYPE_FALSE )
p << message.getArgAsBool( i );
else if ( message.getArgType( i ) == OFXOSC_TYPE_TRIGGER )
p << message.getArgAsTrigger( i );
else if ( message.getArgType( i ) == OFXOSC_TYPE_TIMETAG )
p << (osc::int64)message.getArgAsTimetag( i );
//else if ( message.getArgType( i ) == OFXOSC_TYPE_RGBA_COLOR )
// p << message.getArgAsRgbaColor( i );
else if ( message.getArgType( i ) == OFXOSC_TYPE_BLOB ){
ofBuffer buff = message.getArgAsBlob(i);
osc::Blob b(buff.getData(), (unsigned long)buff.size());
p << b;
}else
{
ofLogError("ofxOscSender") << "appendMessage(): bad argument type " << message.getArgType( i );
assert( false );
}
}
p << osc::EndMessage;
}
void Ableton::displayOscMessage(ofxOscMessage &m)
{
cout << "address : "<< m.getAddress() << endl;
for (int i = 0; i < m.getNumArgs(); i++)
{
if (m.getArgType(i) == OFXOSC_TYPE_INT32) {
cout << " i--> "<<m.getArgAsInt32(i)<<endl;
}
else if (m.getArgType(i) == OFXOSC_TYPE_INT64) {
cout << " j--> "<<m.getArgAsInt64(i)<<endl;
}
else if (m.getArgType(i) == OFXOSC_TYPE_FLOAT) {
cout << " f--> "<<m.getArgAsFloat(i)<<endl;
}
else if (m.getArgType(i) == OFXOSC_TYPE_STRING) {
cout << " s--> "<<m.getArgAsString(i)<<endl;
}
else if (m.getArgType(i) == OFXOSC_TYPE_BLOB) {
cout << " b--> "<<m.getArgAsBlob(i)<<endl;
}
}
}
//--------------------------------------------------------------
string ofApp::getOscMsgAsString(ofxOscMessage m){
string msg_string;
msg_string = m.getAddress();
msg_string += ":";
for(int i = 0; i < m.getNumArgs(); i++){
// get the argument type
msg_string += " " + m.getArgTypeName(i);
msg_string += ":";
// display the argument - make sure we get the right type
if(m.getArgType(i) == OFXOSC_TYPE_INT32){
msg_string += ofToString(m.getArgAsInt32(i));
}
else if(m.getArgType(i) == OFXOSC_TYPE_FLOAT){
msg_string += ofToString(m.getArgAsFloat(i));
}
else if(m.getArgType(i) == OFXOSC_TYPE_STRING){
msg_string += m.getArgAsString(i);
}
else{
msg_string += "unknown";
}
}
return msg_string;
}
static CommandArg messageArgToCommandArg(const ofxOscMessage& message,
int i) {
auto type = message.getArgType(i);
switch (type) {
case OFXOSC_TYPE_INT32:
return message.getArgAsInt32(i);
break;
case OFXOSC_TYPE_INT64:
return message.getArgAsInt64(i);
case OFXOSC_TYPE_FLOAT:
return message.getArgAsFloat(i);
case OFXOSC_TYPE_DOUBLE:
return message.getArgAsDouble(i);
case OFXOSC_TYPE_STRING:
case OFXOSC_TYPE_SYMBOL:
return message.getArgAsString(i);
case OFXOSC_TYPE_TRUE:
return true;
case OFXOSC_TYPE_FALSE:
return false;
default:
break;
}
}
string OscManager::getMessageAsString(const ofxOscMessage& m) const
{
string msg_string;
msg_string = m.getAddress();
for(int i = 0; i < m.getNumArgs(); i++){
// get the argument type
msg_string += " ";
// display the argument - make sure we get the right type
if(m.getArgType(i) == OFXOSC_TYPE_INT32){
msg_string += ofToString(m.getArgAsInt32(i));
}
else if(m.getArgType(i) == OFXOSC_TYPE_FLOAT){
msg_string += ofToString(m.getArgAsFloat(i));
}
else if(m.getArgType(i) == OFXOSC_TYPE_STRING){
msg_string += m.getArgAsString(i);
}
else{
msg_string += "unknown";
}
}
return msg_string;
}
void ramCommunicationManager::updateWithOscMessage(const ofxOscMessage &m) {
if (!dynamic_cast<ofxUIToggle*>(mainPanel.getWidget("Enable"))->getValue()) return;
const std::string addr = m.getAddress();
const std::string name = m.getArgAsString(0);
int index = 0;
int assIdx = -1;
bool isExist = false;
for (int i = 0; i < Instruments.size(); i++) {
if (name == Instruments[i]->getName())
{
index = i;
isExist = true;
}
}
if (!isExist) index = addInstrument(name);
if (addr == RAM_OSC_ADDR_COMMUNICATE_NOTEON) {
bVisible = true;
Instruments[index]->getFloat("velocity") = m.getArgAsFloat(1);
velocities[index]->setValue(m.getArgAsFloat(1));
assIdx = 0;
for (int j = 0; j < assigns.size(); j++) {
if (assigns[j].Found &&
assigns[j].Pindex == index &&
assigns[j].Pposition == assIdx)
assigns[j].Changed = true;
}
}
else if (addr == RAM_OSC_ADDR_COMMUNICATE_NOTEOFF) {
bVisible = true;
Instruments[index]->getFloat("velocity") = 0.0;
velocities[index]->setValue(0.0);
assIdx = 0;
for (int j = 0; j < assigns.size(); j++) {
if (assigns[j].Found &&
assigns[j].Pindex == index &&
assigns[j].Pposition == assIdx)
assigns[j].Changed = true;
}
}
else if (addr == RAM_OSC_ADDR_COMMUNICATE_CC) {
bVisible = true;
int ccNum = m.getNumArgs();
for (int i = 0; i < ccNum - 1; i++) {
string ccLabel = "cc" + ofToString(i);
if (Instruments[index]->contains(ccLabel))
{
Instruments[index]->getFloat(ccLabel) = m.getArgAsFloat(i+1);
ccs[index][i]->setValue(m.getArgAsFloat(i+1));
assIdx = i;
for (int j = 0; j < assigns.size(); j++) {
if (assigns[j].Found &&
assigns[j].Pindex == index &&
assigns[j].Pposition == assIdx)
assigns[j].Changed = true;
}
}
else
{
Instruments[index]->add((*new ofParameter<float>).set(ccLabel,
m.getArgAsFloat(i+1),0.0,1.0));
refleshInstruments();
}
}
}
}
void ofxTidalISF::oscReceiveEvent(ofxOscMessage &m){
//ISF
if(m.getAddress() == "/ofplay"){
//get layer num
int l = 0;
for (int i = 0; i < m.getNumArgs(); i+=2) {
string argName = m.getArgAsString(i);
if (argName == "l") {
l = m.getArgAsInt(i+1);
}
}
//set current inst
for (int i = 0; i < m.getNumArgs(); i+=2) {
string argName = m.getArgAsString(i);
if (argName == "s") {
isfLayers[l]->currentISF = m.getArgAsString(i+1);
}
}
//send params
for (int i = 0; i < m.getNumArgs(); i+=2) {
string argName = m.getArgAsString(i);
//find argName in floatArgs
vector<string>::iterator cIter = find(floatArgs.begin(),floatArgs.end() , argName);
if (cIter != floatArgs.end()) {
float argValue = m.getArgAsFloat(i+1);
for(int j = 0; j < isfLayers[l]->isfs.size(); j++){
if(isfLayers[l]->isfs[j]->getName() == isfLayers[l]->currentISF){
isfLayers[l]->isfs[j]->setUniform<float>(argName, argValue);
}
}
}
}
}
//PostProcess
if(m.getAddress() == "/post"){
//reset postprocess
restPostProcess();
//set postProcess name
for (int i = 0; i < m.getNumArgs(); i+=2) {
string argName = m.getArgAsString(i);
string postName;
if (argName == "s") {
postName = m.getArgAsString(i+1);
if (postName == "bloom") bloom->setEnabled(true);
if (postName == "kaleido") kaleido->setEnabled(true);
if (postName == "noise") noise->setEnabled(true);
if (postName == "rgb") rgb->setEnabled(true);
if (postName == "edge") edge->setEnabled(true);
if (postName == "pixel") pixel->setEnabled(true);
if (postName == "darken") darken->setEnabled(true);
if (postName == "contrast") contrast->setEnabled(true);
if (postName == "conv") conv->setEnabled(true);
if (postName == "dof") dof->setEnabled(true);
if (postName == "sss") sss->setEnabled(true);
if (postName == "fxaa") fxaa->setEnabled(true);
if (postName == "vtilt") vtilt->setEnabled(true);
if (postName == "htilt") htilt->setEnabled(true);
if (postName == "god") god->setEnabled(true);
if (postName == "bleach") bleach->setEnabled(true);
if (postName == "lut") lut->setEnabled(true);
if (postName == "toon") toon->setEnabled(true);
}
}
}
}
void ofxDuration::parseTrackMessage(const ofxOscMessage& m){
for(int i = 0; i < trackNames.size(); i++){
if(trackNames[i] == m.getAddress()){
ofxDurationTrack& track = tracks[trackNames[i]];
bool updated = false;
if(track.type == "Bangs"){
updated = true;
}
else if(track.type == "Curves" || track.type == "LFO"){
if(m.getNumArgs() == 1 && m.getArgType(0) == OFXOSC_TYPE_FLOAT){
track.value = m.getArgAsFloat(0);
updated = true;
}
else {
ofLogError("ofxDuration::parseTrackMessage") << "Incorrect arguments sent to Curves track " << track.name;
}
}
else if(track.type == "Colors"){
if(m.getNumArgs() == 3 &&
m.getArgType(0) == OFXOSC_TYPE_INT32 &&
m.getArgType(1) == OFXOSC_TYPE_INT32 &&
m.getArgType(2) == OFXOSC_TYPE_INT32)
{
track.color = ofColor(m.getArgAsInt32(0),
m.getArgAsInt32(1),
m.getArgAsInt32(2));
updated = true;
}
else {
ofLogError("ofxDuration::parseTrackMessage") << "Incorrect arguments sent to Colors track " << track.name;
}
}
else if(track.type == "Switches"){
if(m.getNumArgs() == 1 && m.getArgType(0) == OFXOSC_TYPE_INT32){
track.on = m.getArgAsInt32(0) != 0;
updated = true;
}
else{
ofLogError("ofxDuration::parseTrackMessage") << "Incorrect arguments sent to Switches track " << track.name;
}
}
else if(track.type == "Flags"){
if(m.getNumArgs() == 1 && m.getArgType(0) == OFXOSC_TYPE_STRING){
track.flag = m.getArgAsString(0);
updated = true;
}
else{
ofLogError("ofxDuration::parseTrackMessage") << "Incorrect arguments sent to Flags track " << track.name;
}
}
else if(track.type == "Audio"){
track.fft.clear();
for(int i = 0; i < m.getNumArgs(); i++){
if(m.getArgType(i) == OFXOSC_TYPE_FLOAT){
float fftdata = m.getArgAsFloat(i);
track.fft.push_back(m.getArgAsFloat(i));
track.maxBinReceived = MAX(fftdata, track.maxBinReceived);
}
}
}
if(updated){
track.lastUpdatedTime = ofGetElapsedTimef();
ofxDurationEventArgs trackEventArgs;
trackEventArgs.duration = this;
trackEventArgs.track = &track;
ofNotifyEvent(events.trackUpdated, trackEventArgs, this);
}
return;
}
}
}
// proceed the message
bool durationReceiver::handle(const ofxOscMessage &_msg) {
if( !isEnabled() ) return false;
// lock mutex
ofScopedLock myLock(oscMutex);
// get incoming track info
if( _msg.getAddress().compare("/dt/info") == 0 ){
// todo: register incomming variable types // tracks and let them be synchronised automatically with inter variables + getters
return true; // we're done
}
// incoming track data
if( canHandle(_msg) ){
string track=_msg.getAddress().substr(DT_PREFIX_LEN,_msg.getAddress().npos);
ofxOscArgType type = OFXOSC_TYPE_NONE;
if( _msg.getNumArgs() > 0 ) type = _msg.getArgType(0);
if(_msg.getNumArgs()>0 && (type == OFXOSC_TYPE_INT32 || type == OFXOSC_TYPE_FLOAT) ){
// /dt/cmd/effect-*
#define cmpEffectCmd "cmd/effect-"
if( track.compare(0, sizeof(cmpEffectCmd)-1, cmpEffectCmd) == 0 ) {
track=track.substr(sizeof(cmpEffectCmd)-1,track.npos);
// enable / disable an effect
// /dt/cmd/effect-enable-effectName
#define cmpEffectCmdEnable "enable-"
if( track.compare(0, sizeof(cmpEffectCmdEnable)-1, cmpEffectCmdEnable) == 0 ) {
effectCmdEventArgs args;
args.command = "enable";
args.targetEffectName = track.substr(sizeof(cmpEffectCmdEnable)-1, track.npos);
args.boolValue = _msg.getArgAsInt32(0);
ofNotifyEvent(basicEffect::effectCommandEvent, args);
}
#define cmpEffectCmdAlpha "alpha-"
else if( track.compare(0, sizeof(cmpEffectCmdAlpha)-1, cmpEffectCmdAlpha) == 0 ) {
effectCmdEventArgs args;
args.command = "alpha";
args.targetEffectName = track.substr(sizeof(cmpEffectCmdAlpha)-1, track.npos);
args.floatValue = _msg.getArgAsFloat(0);
ofNotifyEvent(basicEffect::effectCommandEvent, args);
}
}
}
else if( type == OFXOSC_TYPE_FLOAT){
float value = 0;
if(_msg.getNumArgs()>0) value=_msg.getArgAsFloat(0);
durationFloatEventArgs args;
args.track=track;
//args.type="curve";
args.value=value;
ofNotifyEvent(durationFloatEvent, args);
}
else if(type == OFXOSC_TYPE_INT32){
}
else if(type == OFXOSC_TYPE_STRING){
durationFlagEventArgs args;
args.track=track;
args.flag = _msg.getArgAsString(0);
ofNotifyEvent(durationFlagEvent, args);
}
// handle bangs
else if(type == OFXOSC_TYPE_NONE){
durationBangEventArgs args;
args.track=track;
ofNotifyEvent(durationBangEvent, args);
}
// - - - - - - - - - -
// Notice:
// The following message handling are temporary and static.
// A system needs to be made for synchronising any track by automatically parsing it. #ofxOscVariable
// Hence you can dynamically create new variables and bind them to effect variables
// - - - - - - - - - -
if( track.compare("bang") == 0 && type == OFXOSC_TYPE_NONE ){
{ // send bangEvent
durationBangEventArgs args;
args.track=track;
ofNotifyEvent(durationBangEvent, args);
}
}
else if( track.compare("test") == 0 ){
{ // send flagEvent
string flag = "";
if(_msg.getNumArgs()>0 && type == OFXOSC_TYPE_STRING){
flag=_msg.getArgAsString(0);
}
durationFlagEventArgs args;
args.track=track;
args.flag="";
ofNotifyEvent(durationFlagEvent, args);
}
}
else if( track.compare("lineEffectIntensity") == 0 ){
{ // curve
float value = 0;
if(_msg.getNumArgs()>0)
value=_msg.getArgAsFloat(0);
durationFloatEventArgs args;
args.track=track;
args.type="curve";
args.value=value;
ofNotifyEvent(durationFloatEvent, args);
}
}
// tmp
else if( track.compare("bgVendomeOpacity") == 0 ){
{ // curve
float value = 0;
if(_msg.getNumArgs()>0)
value=_msg.getArgAsFloat(0);
durationFloatEventArgs args;
args.track=track;
args.type="curve";
args.value=value;
ofNotifyEvent(durationFloatEvent, args);
}
}
else if( track.compare("imageBeatEffectIntensity") == 0 ){
{ // curve
float value = 0;
if(_msg.getNumArgs()>0) value=_msg.getArgAsFloat(0);
durationFloatEventArgs args;
args.track=track;
args.type="curve";
args.value=value;
ofNotifyEvent(durationFloatEvent, args);
}
}
/*{
// send bangEvent
durationBangEventArgs args;
args.what="aubioTempo";
ofNotifyEvent(durationBangEvent, args);
}
{
// send bangEvent
durationTempoEventArgs args;
args.bpm = mirCache.bpm;
args.isTempoBis=false;
ofNotifyEvent(durationTempoEventArgs, args);
}
*/
// unknown track, could not get information
else {
// todo: try to add the signal here
//ofLogNotice();
}
return true;
}/*
else if( addr.compare("/aubioTempoBis") == 0 ){
{
// send bangEvent
durationBangEventArgs args;
args.what="aubioTempoBis";
ofNotifyEvent(durationBangEvent, args);
}
{
// send bangEvent
durationTempoEventArgs args;
args.bpm = mirCache.bpm;
args.isTempoBis=true;
ofNotifyEvent(durationTempoEventArgs, args);
}
return true;
}
else if( addr.compare("/aubioBpm") == 0 ){
if(_msg.getNumArgs()>0) mirCache.bpm = _msg.getArgTypeName(0)=="int32"?_msg.getArgAsInt32(0):_msg.getArgAsFloat(0);
return true;
}
else if( addr.compare("/aubioPitch") == 0 ){
if(_msg.getNumArgs()>0) mirCache.pitch = _msg.getArgTypeName(0)=="int32"?_msg.getArgAsInt32(0):_msg.getArgAsFloat(0);
return true;
}
else if( addr.compare("/aubioQuiet") == 0 ){
if(_msg.getNumArgs()>0) mirCache.silence = (_msg.getArgAsInt32(0)==0)?true:false;
return true;
}
else if( addr.compare("/aubioIsPlaying") == 0 ){
if(_msg.getNumArgs()>0) mirCache.isPlaying = (_msg.getArgAsInt32(0)==0)?true:false;
return true;
}
else if( addr.compare("/aubioZcr") == 0 ){
if(_msg.getNumArgs()>0) mirCache.zcr = _msg.getArgTypeName(0)=="int32"?_msg.getArgAsInt32(0):_msg.getArgAsFloat(0);
return true;
}
else if( addr.compare("/balance") == 0 ){
if(_msg.getNumArgs()>0) mirCache.balance = _msg.getArgTypeName(0)=="int32"?_msg.getArgAsInt32(0):_msg.getArgAsFloat(0);
return true;
}
// Fiddle FFT Equaliser
else if( addr.compare(0, 16, "/fiddle_fft/band") == 0 ){ // 16 first chars
int band = ofToInt(addr.substr(16));
if(addr.compare(17, 20, "rms")==0) // rms (volume)
mirCache.fiddleFFT[band][0]=_msg.getArgTypeName(0)=="int32"?_msg.getArgAsInt32(0):_msg.getArgAsFloat(0);
else // pitch
mirCache.fiddleFFT[band][1]=_msg.getArgTypeName(0)=="int32"?_msg.getArgAsInt32(0):_msg.getArgAsFloat(0);
return true;
}
else if( addr.compare("") == 0 ){
return true;
}*/
else {
//cout << "Not recognized OSC = " << _msg.getAddress() << endl;
}
// unrecognized messge
return false;
}
bool tuioVisBase::handleMessage(ofxOscMessage m) {
string address = m.getAddress();
// special cases first:
if (address=="/tuio/2dcur" && m.getNumArgs()==7 && m.getArgType(0)==OFXOSC_TYPE_STRING && m.getArgAsString(0)=="set") {
tuioCursor tc;
tc.s = m.getArgAsInt32(1);
tc.x = m.getArgAsFloat(2);
tc.y = m.getArgAsFloat(3);
tc.dx = m.getArgAsFloat(4);
tc.dy = m.getArgAsFloat(5);
tc.m = m.getArgAsFloat(6);
tc.age = 0;
return cursorCallback(tc);
}
else if (address=="/tuio/2Dcur" && m.getNumArgs()==2 && m.getArgType(0)==OFXOSC_TYPE_STRING && m.getArgAsString(0)=="fseq") {
return frameCallback(m.getArgAsInt32(1));
}
else if (linearCallbacks.find(address) != linearCallbacks.end() && m.getNumArgs()==1) {
return linearCallback(address, m.getArgAsFloat(0));
}
else if (colorCallbacks.find(address) != colorCallbacks.end() && m.getNumArgs()==3) {
return colorCallback(address, m.getArgAsFloat(0), m.getArgAsFloat(1), m.getArgAsFloat(2));
}
// message not handled:
else return false;
}
void ofxRemoteUI::updateParamFromDecodedMessage(ofxOscMessage m, DecodedMessage dm){
string paramName = dm.paramName;
RemoteUIParam original;
bool newParam = true;
unordered_map<string, RemoteUIParam>::iterator it = params.find(paramName);
if ( it != params.end() ){ //found the param, we already had it
original = params[paramName];
newParam = false;
}
RemoteUIParam p = original;
int arg = 0;
switch (dm.argument) {
case FLT_ARG:
p.type = REMOTEUI_PARAM_FLOAT;
p.floatVal = m.getArgAsFloat(arg); arg++;
if(m.getNumArgs() > 1){
p.minFloat = m.getArgAsFloat(arg); arg++;
p.maxFloat = m.getArgAsFloat(arg); arg++;
}
if (p.floatValAddr){
*p.floatValAddr = p.floatVal;
}break;
case INT_ARG:
p.type = REMOTEUI_PARAM_INT;
p.intVal = m.getArgAsInt32(arg); arg++;
p.minInt = m.getArgAsInt32(arg); arg++;
p.maxInt = m.getArgAsInt32(arg); arg++;
if (p.intValAddr){
*p.intValAddr = p.intVal;
}break;
case COLOR_ARG:
p.type = REMOTEUI_PARAM_COLOR;
p.redVal = (int)m.getArgAsInt32(arg); arg++;
p.greenVal = (int)m.getArgAsInt32(arg); arg++;
p.blueVal = (int)m.getArgAsInt32(arg); arg++;
p.alphaVal = (int)m.getArgAsInt32(arg); arg++;
if (p.redValAddr){
*p.redValAddr = p.redVal;
*(p.redValAddr+1) = p.greenVal;
*(p.redValAddr+2) = p.blueVal;
*(p.redValAddr+3) = p.alphaVal;
}break;
case ENUM_ARG:{
p.type = REMOTEUI_PARAM_ENUM;
p.intVal = m.getArgAsInt32(arg); arg++;
p.minInt = m.getArgAsInt32(arg); arg++;
p.maxInt = m.getArgAsInt32(arg); arg++;
if (p.intValAddr){
*p.intValAddr = p.intVal;
}
int n = m.getNumArgs() - 5 - 3; // 3 >> the int vals, 5 >> 4 colors + 1 group
int i = 0;
p.enumList.clear();
for (i = 0; i < n; i++) {
p.enumList.push_back( m.getArgAsString(arg + i) );
}
arg = arg + i;
}break;
case BOL_ARG:
p.type = REMOTEUI_PARAM_BOOL;
p.boolVal = m.getArgAsInt32(arg) == 0 ? false : true; arg++;
if (p.boolValAddr){
*p.boolValAddr = p.boolVal;
}break;
case STR_ARG:
p.type = REMOTEUI_PARAM_STRING;
p.stringVal = m.getArgAsString(arg); arg++;
if (p.stringValAddr){
*p.stringValAddr = p.stringVal;
}break;
case SPACER_ARG:
p.type = REMOTEUI_PARAM_SPACER;
p.stringVal = m.getArgAsString(arg); arg++;
break;
case NULL_ARG: RUI_LOG_ERROR << "updateParamFromDecodedMessage NULL type!"; break;
default: RUI_LOG_ERROR << "updateParamFromDecodedMessage unknown type!"; break;
}
if(m.getNumArgs() > 1){
p.r = m.getArgAsInt32(arg); arg++;
p.g = m.getArgAsInt32(arg); arg++;
p.b = m.getArgAsInt32(arg); arg++;
p.a = m.getArgAsInt32(arg); arg++;
p.group = m.getArgAsString(arg); arg++;
}
if ( !p.isEqualTo(original) || newParam ){ // if the udpdate changed the param, keep track of it
paramsChangedSinceLastCheck.insert(paramName);
}
//here we update our param db
//params[paramName] = p;
if(newParam)
addParamToDB(p, paramName);
else
params[paramName] = p;
}
