Collidoscope

        ci::vec2	mCloudCenter; // initial positin of the particle 

        ci::vec2	mVel;         // velocity 

        float       mCloudSize;   // how big is the area where particle float around. When a particle hits the 

                                  //   border of the area it gets deflected 

        int			mAge;      // when mAge == mLifeSpan the particle is disposed 

        int			mLifespan; // how long a particle lives

        bool        mFlyOver;  // some particles last longer and fly over the screen and reach the other user

    ci::gl::VboRef			mParticleVbo;    // virtual buffer object 

    // uses Cinder (and OpenGL) virtual buffer object based drawing

    // see ParticleSphereCPU example in Cinder library 

    // creates glsl program to run the batch with 

    // update the positions of the particles and dispose them if they're reached their timespan

    // Copy particle data onto the GPU.

	// Map the GPU memory and write over it.

    // reduce the particles liearly to the total number of particles already present 

    // the more particles aleary present the less particle are added

		//a.k.a. return if reached kMaxParticles 

    // init cinder batch drawing

        // A chunk of audio corresponds to a certain time according to sample rate.

        // Use elapsed time to advance through chunks so that the cursor is animated 

        // and goes from start to end of the seleciton in the time span of the grain 

        // check we don't go too far off 

//--------------------------------------static utilities------------------------------------------

  // FIXME seg fault at shutdown 

// copy audio from node buffer to jack port 

// copy audio from jack port to  node buffer

// -------------------------------OutputDeviceNodeJack-------------------------------------------

    // retrieve user data 

        // this is from some cinder library code but it should not happen in Collidoscope as the context is set

    // process the whole audio graph using by recursively pulling the input all the way to the top of the graph 

	//if( outputDeviceNode->checkNotClipping() ){

        //for( size_t chan = 0; chan < 2; chan++)

		//    zeroJackPort( outputDeviceNode->mOutputPorts[chan], nframes );

	//} 

    //else {

    //}

    // connect to Jack server 

    // prepare user data for callback 

    // setup input ports. Note that the reference to the input node is used. 

    /* Tell the Jack server that we are ready to roll.  Our callback will start running now. */

//----------------------------------------- InputDeviceNodeJack ---------------------------------------------------

// This is called when the output node pull all the inputs in the jack callback. 

// Takes audio interface input from the jack port and copies it in the node buffer

//-------------------------------------------ContextJack-----------------------------------------------------------

OutputDeviceNodeRef	ContextJack::createOutputDeviceNode( const DeviceRef &device, const Node::Format &format )

{

    if( mOutputDeviceNode  == nullptr ) {

        auto thisRef = std::static_pointer_cast<ContextJack>( shared_from_this() );

        mOutputDeviceNode = makeNode( new OutputDeviceNodeJack( device, Node::Format().channels(2), thisRef ) ) ;

        // the output device node must have a reference to input device node. In OutputDeviceNodeJack::initialize() 

        // the input node is passed the jack input ports that it will use to fetch incoming audio from the audio interface

        // Whichever node (input or ouput) gets initialized after the other, executes the following block:

        if( mInputDeviceNode != nullptr){

            auto castedOutputDeviceNode = std::static_pointer_cast<OutputDeviceNodeJack>( mOutputDeviceNode );

            castedOutputDeviceNode->setInput( mInputDeviceNode );   

        }

    }

	return mOutputDeviceNode;

}

InputDeviceNodeRef ContextJack::createInputDeviceNode( const DeviceRef &device, const Node::Format &format  )

{

    if( mInputDeviceNode  == nullptr ) {

        auto thisRef = std::static_pointer_cast<ContextJack>( shared_from_this() );

        mInputDeviceNode = makeNode( new InputDeviceNodeJack( device, Node::Format().channels(2), thisRef ) ) ;

        // the output device node must have a reference to input device node. In OutputDeviceNodeJack::initialize() 

        // the input node is passed the jack input ports that it will use to fetch incoming audio from the audio interface

        // Whichever node (input or ouput) gets initialized after the other, executes the following block:

        if( mOutputDeviceNode != nullptr){

            auto castedOutputDeviceNode = std::static_pointer_cast<OutputDeviceNodeJack>( mOutputDeviceNode );

            castedOutputDeviceNode->setInput( mInputDeviceNode );   

        }

    }

	return mInputDeviceNode;

}

/**

 * OutputNode (as in the cinder::audio::OutputNode) that sends audio to the sound card using the jack audio callback method. 

 */ 

    /** Gives this output node a reference to the JackInputNode. 

     *  In initialize() the reference is used to give the input node access to jack input ports 

     */

    // this is called by jack in the audio thread at every tick of the sound card 

    /**

     * RenderData is passed as user_data to jack when the jack process callback is installed

     */ 

/**

 * InputNode (as in the cinder::audio::OutputNode) that reads audio from the sound card using the jack audio callback method. 

 */ 

	ContextJack() {}

	virtual ~ContextJack() {}

    // hardcoded devices. They are always JackIn and JackOut 

    // open a jack client, get info and close

//hardcoded name same as key 

/**

 * DeviceManager ( as in cinder::audio::DeviceManager ) that handle the hardware device through the jack library.

 * Note that this is not suitable for general purpose use. Most of the functionalities are indeed hard coded

 * just to suit Collidoscope needs. In particular only two input and two output ports are assumed. 

 *

 */