/CollidoscopeApp - Diff - Collidoscope

         */
         size_t getRecordWaveAvailable( size_t index );
         /**
         * Called from the graphic thread. Reads count elements from the wave ring buffer into \a buffer.
         * Called from the graphic thread. Reads \a count elements from the wave ring buffer into \a buffer.
         * The wave ring buffer is used to pass the size of the wave chunks from the audio thread to the graphic thread,
         * when a new wave is recorded.
+        *
-...
         // nodes for recording audio input into buffer. Also sends chunks information through
         // non-blocking queue
         std::array< BufferToWaveRecorderNodeRef, NUM_WAVES > mBufferRecorderNodes;
         // pgranulars for loop synths
         // pgranulars wrapped in a Cinder::Node
         std::array< PGranularNodeRef, NUM_WAVES > mPGranularNodes;

     /**
      * A \a Node in the audio graph of the Cinder audio library that records input in a buffer.
+     *
      * This class is similar to \a cinder::audio::BufferRecorderNode (it's a derivative work of this class indeed) but it has an additional feature.
      * When recording it uses the audio input samples to compute the size values of the visual chunks.
      * This class is similar to \a cinder::audio::BufferRecorderNode (it's a derivative work of this class indeed) but it has an additional feature:
      * when recording, it uses the audio input samples to compute the size values of the visual chunks.
      * The chunks values are stored in a ring buffer and fetched by the graphic thread to paint the wave as it gets recorded.
+     *
      */

+     *
      * A chunk of audio in Collidoscope low-fi visual wave.
+     *
      * The visual wave of Collidoscope is made out of a number of bars that mimics in a low-fi fashion the typical waveform based representation of audio.
      * The visual wave of Collidoscope is made out of a number of bars that mimic, in a low-fi fashion, the typical waveform-based representation of audio.
      * A Chunk is one of the bars of the visual wave.
+     *
      */
-...
         const static float kHalfWidth;
         /**
          * Constructor, takes as argument the index of this chunk in the wave
          * Constructor, takes as argument the index of this chunk in the wave that contains it
          */
         Chunk( size_t index );
-...
         float inline getBottom() const { return mAudioBottom; }
         /**
          * Reset this chunks. When a chunk is reset it starts shrinking until it disappears.
          * Reset this chunks. When a chunk is reset, it starts shrinking until it disappears or setTop/setBottom are called again
+         *
          */
         void reset(){

+        }
         /**
          * Returns wave's selection color
          * Returns wave selection color
          */
         ci::Color getWaveSelectionColor(size_t waveIdx) const
+        {
-...
         /**
          * The value returned is used when creating the oscilloscope.
          * The oscilloscope represents the audio output buffer graphically. However it doesn't need to be as refined as the
          * audio wave and it's downsampled using the following formula :  number of oscilloscope points = size o audio output buffer / getOscilloscopeNumPointsDivider()
          * audio wave and it's downsampled using the following formula :  (number of oscilloscope points) = (size of audio output buffer) / getOscilloscopeNumPointsDivider()
          */
         size_t getOscilloscopeNumPointsDivider() const
+        {

CollidoscopeApp/include/DrawInfo.h
58	58	}
59	59
60	60	/**
61		* Maps a value in the audio space [-1.0, 1.0] to a position on the y axis of this DrawInf's bounding area.
	61	* Maps a value in the audio space [-1.0, 1.0] to a position on the y axis of this DrawInfo's bounding area.
62	62	*
63	63	*/
64	64	float audioToHeigt(float audioSample) const {
...	...
99	99	}
100	100
101	101	/**
102		* Flips y according to the index of the wave. It is needed because the second wave in collidoscope is upside down from the orientation oftthe screen.
	102	* Flips y according to the index of the wave. It is needed because the second wave in collidoscope is drawn upside down in the screen.
103	103	*/
104	104	int flipY(int y) const
105	105	{
...	...
110	110	}
111	111
112	112	/**
113		* Returns x. not used at he moment.
	113	* Returns x. not used at the moment.
114	114	*
115	115	*/
116	116	int flipX(int x) const

     /*
      Copyright (C) 2016  Queen Mary University of London
      Author: Fiore Martin
      Author: Fiore Martin, based on CCRMA STK ADSR.h (https://ccrma.stanford.edu/software/stk/classstk_1_1ADSR.html)
      This file is part of Collidoscope.
-...
      You should have received a copy of the GNU General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
      This file incorporates work covered by the following copyright and permission notice:
         The Synthesis ToolKit in C++ (STK)
         Copyright (c) 1995--2016 Perry R. Cook and Gary P. Scavone
         Permission is hereby granted, free of charge, to any person obtaining
         a copy of this software and associated documentation files (the
         "Software"), to deal in the Software without restriction, including
         without limitation the rights to use, copy, modify, merge, publish,
         distribute, sublicense, and/or sell copies of the Software, and to
         permit persons to whom the Software is furnished to do so, subject to
         the following conditions:
         The above copyright notice and this permission notice shall be
         included in all copies or substantial portions of the Software.
         Any person wishing to distribute modifications to the Software is
         asked to send the modifications to the original developer so that they
         can be incorporated into the canonical version.  This is, however, not
         a binding provision of this license.
         THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
         EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
         MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
         IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
         ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
         CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
         WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
     */
     #pragma once

     namespace collidoscope {
     // Exception thrown by MIDI system
     class MIDIException : public std::exception
+    {
     public:
-...
         // of saving all the messages in mMIDIMessages just save the last received in mPitchBendMessages
         // and optimize away redundant messages.
         std::array< MIDIMessage, NUM_WAVES > mPitchBendMessages;
         // Same principle of pitch bend messages
         // Same principle as mPitchBendMessages
         std::array< MIDIMessage, NUM_WAVES > mFilterMessages;
         // vecotr containing all the MIDI input devices detected.
         // vector containing all the MIDI input devices detected.
         std::vector< std::unique_ptr <RtMidiIn> > mInputs;
         // Used for mutual access to the MIDI messages by the MIDI thread and the graphic thread.
         std::mutex mMutex;

         // message sent when a new recording starts. The gui resets the wave upon receiving it.
         WAVE_START,
         // new grain created
         TRIGGER_UPDATE,
         // synth became idle
         TRIGGER_END,
         NOTE_ON,
-...
     /** Message sent from the audio thread to the graphic wave when a new wave is recorded.
+     *
      *  The graphic thread set the chunks of the wave to reflect the level of the recorded audio.
      *  The algorithm takes the maximum and minimum value of a group of samples and this becomes the top and bottom of the samples.
      *  It contains the inde
      *  the cursor position when the grains are reset.
      *  The graphic thread sets the chunks of the wave to reflect the level of the recorded audio.
      *  The algorithm takes the maximum and minimum value of a group of samples and this becomes the top and bottom of the chunk.
      *  The message carries also the index of the chunk it refers to
      */
     struct RecordWaveMsg
+    {

             {}
         /**
          * Sets the value of a point of the oscilloscope. The value is passed as an audio coordinate [-1.0, 1.0].
          * A reference to DrawInfo is passed to calculate the graphic coordinate of the point based on the audio value passed.
          * Sets the value of a point of the oscilloscope. The value is passed in audio coordinates [-1.0, 1.0].
          * A reference to DrawInfo is passed to calculate the graphic coordinate of the point based on the audio values passed.
          */
         void  setPoint( int index, float audioVal, const DrawInfo &di ){
-...
             mLine.getPoints()[index].x = float( di.flipX( int(xRatio) ) );
             mLine.getPoints()[index].y = float( di.flipY( int(yRatio) ) );
             // add the missing line to reach the right of the window
             // indeed the scope starts from 0 to size -1 and adds xRatio
             // to each new point to the line from n-1 to n is missing
             // add the missing line to reach the right of the window.
             // Indeed, the scope starts from 0 to size-1 and adds xRatio
             // to each new point. The line from n-1 to n is therefore missing.
             if (index == mNumPoints - 1){
                 xRatio += ( di.getWindowWidth() / mNumPoints );
                 xRatio = ceil( xRatio ); // ceil because the division might left one pixel out

     /*
      Copyright (C) 2002 James McCartney.
      Copyright (C) 2016  Queen Mary University of London
      Author: Fiore Martin
      Author: Fiore Martin, based on Supercollider's (http://supercollider.github.io) TGrains code and Ross Bencina's "Implementing Real-Time Granular Synthesis"
      This file is part of Collidoscope.
-...
     /**
      * The very core of the Collidoscope audio engine: the granular synthesizer.
      * Based on SuperCollider's TGrains and Ross Becina's "Implementing Real-Time Granular Synthesis"
      * Based on SuperCollider's TGrains and Ross Bencina's "Implementing Real-Time Granular Synthesis"
+     *
      * It implements Collidoscope's selection-based approach to granular synthesis.
      * A grain is basically a selection of a recorded sample of audio.
      * Grains are played in a loop: they are retriggered each time they reach the end of the selection.
      * However, if the duration coefficient is greater than one, a new grain is re-triggered before the previous one is done.
      * The grains start to overlap with each other and create the typical eerie sound of grnular synthesis.
      * Grains are played in a loop: they are re-triggered each time they reach the end of the selection.
      * However, if the duration coefficient is greater than one, a new grain is re-triggered before the previous one is done,
      * the grains start to overlap with each other and create the typical eerie sound of grnular synthesis.
      * Also every time a new grain is triggered, it is offset of a few samples from the initial position to make the timbre more interesting.
+     *
+     *
-...
+        {
             double phase;    // read pointer to mBuffer of this grain
             double rate;     // rate of the grain. e.g. rate = 2 the grain will play twice as fast
             bool alive;      // whether this grain is alive. Not alive means it has been processed and can be replanced by another grain
             bool alive;      // whether this grain is alive. Not alive means it has been processed and can be replaced by another grain
             size_t age;      // age of this grain in samples
             size_t duration; // duration of this grain in samples. minimum = 4
-...
+         *
          * \param buffer a pointer to an array of T that contains the original sample that will be granulized
          * \param bufferLen length of buffer in samples
          * \rand function returning of type size_t ()(void) that is called back each time a new grain is generated. The returned value is used
          * \rand function of type size_t ()(void) that is called back each time a new grain is generated. The returned value is used
          * to offset the starting sample of the grain. This adds more colour to the sound especially with small selections.
          * \triggerCallback function of type void ()(char, int) that is called back each time a new grain is triggered.
          *      The function is passed the character 't' as first parameter when a new grain is triggered and the characted 't' when the synths becomes idle.
          * \ID id of this PGrain is passed to the triggerCallback function as second parameter to identify this PGranular as the caller.
          * \triggerCallback function of type void ()(char, int) that is called back each time a new grain is generated.
          *      The function is passed the character 't' as first parameter when a new grain is triggered and the characted 'e' when the synth becomes idle (no sound).
          * \ID id of this PGrain. Passed to the triggerCallback function as second parameter to identify this PGranular as the caller.
          */
         PGranular( const T* buffer, size_t bufferLen, size_t sampleRate, RandOffsetFunc & rand, TriggerCallbackFunc & triggerCallback, int ID ) :
             mBuffer( buffer ),
-...
         /**
          * Runs the granular engine and stores the output in \a audioOut
+         *
          * \param pointer to an array of T. This will be filled with the output of PGranular. It needs to be at least \a numSamples lond
          * \param tempBuffer a temporary buffer used to store the envelope value. It needs to be at leas \a numSamples long
          * \param pointer to an array of T. This will be filled with the output of PGranular. It needs to be at least \a numSamples long
          * \param tempBuffer a temporary buffer used to store the envelope value. It needs to be at least \a numSamples long
          * \param numSamples number of samples to be processed
          */
         void process( T* audioOut, T* tempBuffer, size_t numSamples )
-...
         // synthesize a single grain
         // audioOut = pointer to audio block to fill
         // numSamples = numpber of samples to process for this block
         // numSamples = number of samples to process for this block
         void synthesizeGrain( PGrain &grain, T* audioOut, T* envelopeValues, size_t numSamples )
+        {
             // copy all grain data into local variable for faster porcessing
             // copy all grain data into local variable for faster processing
             const auto rate = grain.rate;
             auto phase = grain.phase;
             auto age = grain.age;
-...
+            }
             if ( age == duration ){
                 // if it porocessed all the samples left to leave ( numSamplesToOut = duration-age)
                 // then the grain is had finished
                 // if it processed all the samples left to leave ( numSamplesToOut = duration-age)
                 // then the grain is finished
                 grain.alive = false;
+            }
             else{
-...
         // length of mBuffer in samples
         const size_t mBufferLen;
         // offset in the buffer where the grains start. a.k.a. seleciton start
         // offset in the buffer where the grains start. a.k.a. selection start
         size_t mGrainsStart;
         // attenuates signal prevents clipping of grains
         // attenuates signal prevents clipping of grains (to some degree)
         T mAttenuation;
         // grain duration in samples
         double mGrainsDurationCoeff;
         // duration of grains is selcection size * duration coeff
         // duration of grains is selection size * duration coeff
         size_t mGrainsDuration;
         // rate of grain, affects pitch
         double mGrainsRate;

     struct RandomGenerator;
     /*
     A node in the Cinder audio graph that holds a PGranular
     A node in the Cinder audio graph that holds PGranulars for loop and keyboard playing
     */
     class PGranularNode : public ci::audio::Node
+    {
-...
     private:
         // Wraps a std::atomic but get() returns a boost::optional that is set to a real value only when the atomic has changed.
         //  It is used to avoid calling PGranulat setter methods with *  the same value at each audio callback.
         //  It is used to avoid calling PGranular setter methods with the same value at each audio callback.
         template< typename T>
         class LazyAtomic
+        {
-...
         // pointers to PGranular objects
         std::unique_ptr < collidoscope::PGranular<float, RandomGenerator, PGranularNode > > mPGranularLoop;
         std::array<std::unique_ptr < collidoscope::PGranular<float, RandomGenerator, PGranularNode > >, kMaxVoices> mPGranularNotes;
         // maps midi notes to pgranulars. When a noteOff is received maks sure the right PGranular is turned off
         // maps midi notes to pgranulars. When a noteOff is received makes sure the right PGranular is turned off
         std::array<int, kMaxVoices> mMidiNotes;
         // pointer to the random generator struct passed over to PGranular
         std::unique_ptr< RandomGenerator > mRandomOffset;
         // buffer containing the recorder audio, to pass to PGranular in initialize()
         // buffer containing the recorded audio, to pass to PGranular in initialize()
         ci::audio::Buffer *mGrainBuffer;
         ci::audio::BufferRef mTempBuffer;

             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
                                       // border of the area it gets deflected
             int			mAge;      // when mAge == mLifeSpan the particle is disposed
             int			mLifespan; // how long a particle lives

             void setSize( size_t size );
             /** The particle spread parameter affects the size of the cloud of particles
              *  The cloud is the visual conterpart of the grain duration coefficien in sound.
              *  The cloud is the visual counterpart of the grain duration coefficient in sound.
              *  Indeed spread accepts values from 1 to 8, exactly as the duration coefficient
              */
             void inline setParticleSpread( float spread ){
-...
         /* Maps id of the synth to cursor. There is one cursor for each Synth being played */
         std::map < SynthID, Cursor > mCursors;
         /** Holds the positions of the cursor, namely on which chunk the cursor is currently */
         /** Holds the positions of the cursor, namely on which chunk the cursor is currently on */
         std::vector<int> mCursorsPos;
     public:
-...
         // value used to identify the loop for cursor position
         static const int kLoopNote = -1;
         static const cinder::Color CURSOR_CLR;
         /* must be in sync with supercollider durationFactor ControlSpec max */
         static const int MAX_DURATION = 8;
     #ifdef USE_PARTICLES
         static const int PARTICLESIZE_COEFF = 40;
     #endif
         /** Resetting a wave makes it shrink until it disappears. Each time a new sample is recorder the wave is reset
         /** Resetting a wave makes it shrink until it disappears. Each time a new sample is recorded, the wave is reset.
          *  \param onlyChunks if false the selection is also set to null, if true only the chunks are reset
          */
         void reset(bool onlyChunks);
-...
         const Chunk & getChunk(size_t index);
         /** places the cursor on the wave. Every cursor is associated to a synth voice of the audio engine.
         /** Places the cursor on the wave. Every cursor is associated to a synth voice of the audio engine.
          *  The synth id identifies uniquely the cursor in the internal map of the wave.
          *  If the cursor doesn't exist it is created */
         inline void setCursorPos( SynthID id, int pos, const DrawInfo& di ){
-...
             cursor.lastUpdate = ci::app::getElapsedSeconds();
     #ifdef USE_PARTICLES
             // The idea is that, if the duration is greater than 1.0, the cursor continues in form of particles
             // The smaller the selection the more particles; the bigger the duration the more particles
             // The idea is that, if the duration is greater than 1.0, the cursor continues in form of particles.
             // The smaller the selection the more particles; the bigger the duration the more particles.
             if (mSelection.getParticleSpread() > 1.0f){
                 /* amountCoeff ranges from 1/8 to 1 */
                 const float amountCoeff = (mSelection.getParticleSpread() / MAX_DURATION);
                 /* get radom point within seleciton as center of the particle */
                 vec2 centrePoint; // was former getRandomPoint
                 vec2 centrePoint;
                 const int randomChunkIndex = ci::Rand::randInt(mSelection.getStart(), mSelection.getEnd() );
                 centrePoint.x = di.flipX( 1 + (randomChunkIndex * (2 + Chunk::kWidth)) + Chunk::kWidth / 2 );
-...
         cinder::Color mColor;
         // How much filter is applied in audio. It affects the alpha value of the selection color.
         float mFilterCoeff;
         // cinder gl batch for batch drawing

     */
     #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