Question

I am developing a program for a performance artist who needs a backdrop that is running various programs via openFrameworks. He needs a way to be able to easily switch between them somehow. Is there some way of creating a master shell which loads or unloads other openframeworks files?

Answer 1

If you have a way to terminate RunApp() from the clientside (via a quit button), you can wrap the call in a scripting language via tcl or python. You’ll end up with an interactive shell where you can run different apps and set parameters.

For sake of simplicity i’ll leave out some details and assume we do the language binding with boost::python. A more detailed read about this is in this article, the boost::python documentation is here.

The main idea is to create a domain specific language/set of wrappers for OF, which can be used to create OF objects and access their methods either interactively via a shell or through a script.

Boost object bindings work roughly like this (quote from 1):

First define the class in C++

struct World
{
    void set(std::string msg) { this->msg = msg; }
    std::string greet() { return msg; }
    std::string msg;
};

Then, expose it as a python-module

#include <boost/python.hpp>
BOOST_PYTHON_MODULE(hello)
{
    class_<World>("World")
      .def("greet", &World::greet)
      .def("set", &World::set)
    ;
}

Which looks like this in use in an interactive python session:

>>> import hello
>>> planet = hello.World()
>>> planet.set('howdy')
>>> planet.greet()
'howdy'

Now since one can wrap any class or method there are many possibilities on how to actually tap into OF. The one i was referring to in this answer would be to have f.e. two Apps, App1, App2 implemented in C++/OF, then link to that implementation in python.

The interactive session would look something like this:

>>> import myofapps
>>> a1 = myofapps.App1()
>>> a2 = myofapps.App2()
>>> a1.run() # blocked here, until the app terminates
>>> a2.run() # then start next app .. and so forth
>>> a1.run()

I’m not an OF hacker but another (easier) possibility might be to interactively change the content of f.e. ofApp::draw() in an App (running in a thread). This could be done by embedding a custom object parametrizable from within the python interpreter:

/// custom configurator class

class MyObj {
   private int colorRed;

   // getter
   int getRed () {
      return colorRed;
   }

   // setter
   void setRed(int r) {
      colorRed = r;
   }

   /// more getters/setters code
   ...
};

/// the boost wrapping code (see top of post)
...

/// OF code here

void testApp::draw() {

    // grab a reference to MyObj (there are multiple ways to do that)
    // let's assume there's a singleton which holds the reference to it
    MyObj o = singleton.getMyObj();

    // grab values
    int red = o.getRed ();

    // configure color
    ofSetColor(red,0,0,100);

    // other OF drawing code here...
}

Which once the OF app runs, could be used to change color interactively from within your interpreter:

>>> import myofapps
>>> a1 = myofapps.App1()
>>> c1 = myofapps.MyObj();
>>> a1.run() # this call would have to be made non-blocking by running the 
>>>          # app in a thread and returning right away
>>> c1.setRed(100);

... after a minute set color to a different value

>>>> c1.setRed(200);