/CollidoscopeApp/src - Diff - Collidoscope

     */
     #include "AudioEngine.h"
     // app.h include not used
     #include "cinder/app/App.h"
     //FIXME remove App.h include
     #include "Log.h"
     using namespace ci::audio;
-...
         /* audio context */
         auto ctx = Context::master();
         /* audio inpu device */
         /* audio input device */
         auto inputDeviceNode = ctx->createInputDeviceNode( Device::getDefaultInput() );
-...
             /* this prevents the node from recording before record is pressed */
             mBufferRecorderNodes[chan]->setAutoEnabled( false );
             // route the input part of the audio graph. Two channels input goes into
             // one channel route and to one channel buffer recorder
             // route the input part of the audio graph. Two channels input goes into one channel route
             // and from one channel route to one channel buffer recorder
             inputDeviceNode >> mInputRouterNodes[chan]->route( chan, 0, 1 ) >> mBufferRecorderNodes[chan];
             // create PGranular loops passing the buffer of the RecorderNode as argument to the contructor
             // use -1 as ID
             // use -1 as ID as the loop corresponds to no midi note
             mPGranularNodes[chan] = ctx->makeNode( new PGranularNode( mBufferRecorderNodes[chan]->getRecorderBuffer(), mCursorTriggerRingBufferPacks[chan]->getBuffer() ) );
             // create filter nodes
-...
             // filter goes to output
             mLowPassFilterNodes[chan] >> mOutputRouterNodes[chan]->route( 0, chan, 1 ) >> ctx->getOutput();
             // what goes to output goes to scope
             // what goes to output goes to oscilloscope as well
             mLowPassFilterNodes[chan] >> mOutputMonitorNodes[chan];
+        }

     void Chunk::update( const DrawInfo &di )
+    {
         using namespace ci;
         /* if resetting animate the chunks to shrink to 0 size */
         /* if resetting animate the chunks to nicely shrink to 0 size */
         if ( mResetting ){
             if ( mAnimate > 0.0f ){
                 mAnimate -= 0.1f;
-...
+            }
+        }
         mX = di.flipX( 1 + (mIndex * (2 + kWidth)) ); // FIXME this should happen only once when resized
         mX = di.flipX( 1 + (mIndex * (2 + kWidth)) ); // FIXME more efficient if it happens only once when resized
+    }
     void Chunk::draw( const DrawInfo& di, ci::gl::BatchRef &batch ){
-...
         const float chunkHeight = mAnimate * mAudioTop * di.getMaxChunkHeight();
         // place the chunk in the right position brigns back the y of chunkHeight/2 so
         // place the chunk in the right position brings back the y of chunkHeight/2 so
         // so that after scaling the wave is still centered at the wave center
         gl::translate( mX, di.getWaveCenterY() - ( chunkHeight / 2 ) - 1 );
         // FIXME todo use max between top and bottom
         // scale according to audio amplitude
         gl::scale( 1.0f, chunkHeight );
         batch->draw();

         array< shared_ptr< Wave >, NUM_WAVES > mWaves;
         array< shared_ptr< DrawInfo >, NUM_WAVES > mDrawInfos;
         array< shared_ptr< Oscilloscope >, NUM_WAVES > mOscilloscopes;
         // buffers to read the wave messages as a new wave gets recorded
         // buffer to read the WAVE_* messages as a new wave gets recorded
         array< RecordWaveMsg*, NUM_WAVES> mRecordWaveMessageBuffers;
         //buffer to read the TRIGGER_* messages as the pgranulars play
         array< vector< CursorTriggerMsg >, NUM_WAVES > mCursorTriggerMessagesBuffers;
         double mSecondsPerChunk;

+    {
         mTempBuffer = std::make_shared< ci::audio::Buffer >( getFramesPerBlock() );
         mRandomOffset.reset( new RandomGenerator( getSampleRate() / 100 ) ); // divided by 100 corresponds to times 0.01 in the time domain
         mRandomOffset.reset( new RandomGenerator( getSampleRate() / 100 ) ); // divided by 100 corresponds to multiplied by 0.01 in the time domain
         /* create the PGranular object for looping */
         mPGranularLoop.reset( new collidoscope::PGranular<float, RandomGenerator, PGranularNode>( mGrainBuffer->getData(), mGrainBuffer->getNumFrames(), getSampleRate(), *mRandomOffset, *this, -1 ) );
-...
+        }
+    }
     // Called back when new grnular is triggered of turned off. Sends notification message to graphic thread.
     // Called back when new PGranular is triggered or turned off. Sends notification message to graphic thread.
     void PGranularNode::operator()( char msgType, int ID ) {
         switch ( msgType ){
-...
+            }
             if ( !synthFound ){
                 // then look for a free synth
                 // then look for a free voice
                 for ( int i = 0; i < kMaxVoices; i++ ){
                     if ( mMidiNotes[i] == kNoMidiNote ){

     mNumParticles( 0 )
+    {
         // uses Cinder (and OpenGL) virtual buffer object based drawing
         // uses Cinder (and OpenGL) drawing based on virtual buffer object
         // see ParticleSphereCPU example in Cinder library
         mParticles.assign( kMaxParticles, Particle() );
-...
     void ParticleController::updateParticles()
+    {
         // update the positions of the particles and dispose them if they're reached their timespan
         // update the positions of the particles and dispose them if they've reached their timespan
         for ( size_t i = 0; i < mNumParticles; i++ ){
             Particle &particle = mParticles[i];
-...
     void ParticleController::addParticles(int amount, const vec2 &initialLocation, const float cloudSize)
+    {
         // reduce the particles liearly to the total number of particles already present
         // reduce the particles linearly to the total number of particles already present
         // the more particles aleary present the less particle are added
         int reduction = ci::lmap<int>(mNumParticles, 0, kMaxParticles, 0, kMaxParticleAdd);
         amount -= reduction;

             double elapsed = now - itr->second.lastUpdate;
             // 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
             // A chunk of audio corresponds to a certain time lenght of audio, according to sample rate.
             // Use elapsed time to advance through chunks so that the cursor is animated.
             // So it goes from start to end of the selection in the time span of the grain
             itr->second.pos = mSelection.getStart() + int( elapsed / secondsPerChunk );
             // check we don't go too far off
-...
                     gl::color(mSelection.getColor().r, mSelection.getColor().g, mSelection.getColor().b, selectionAlpha);
+                }
                 // check if one of the cursors is positioned in this chunk
                 // check if one of the cursors is positioned in this chunk, and draw it white if it is
                 if (std::find(mCursorsPos.begin(), mCursorsPos.end(),i) != mCursorsPos.end() ){
                     gl::color(CURSOR_CLR);
                     mChunks[i].draw( di, mChunkBatch );
-...
                     /* draw the selection bar with a transparent selection color */
                     gl::color(mSelection.getColor().r, mSelection.getColor().g, mSelection.getColor().b, 0.5f);
                     mChunks[i].drawBar( di, mChunkBatch );
                     /* set the colo to the wave */
                     /* set the color to the wave */
                     gl::color(this->mColor);
+                }
+            }

Collidoscope

Revision 16:4dad0b810f18 CollidoscopeApp/src