/CollidoscopeApp/src - Diff - Collidoscope

     /*
      Copyright (C) 2016  Queen Mary University of London
      Author: Fiore Martin
      This file is part of Collidoscope.
      Collidoscope is free software: you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
      This program is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
      GNU General Public License for more details.
      You should have received a copy of the GNU General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
     */
     #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;
     /* Frequency ratios in the chromatic scale */
     double chromaticRatios[] = {
 ,
 .0594630943591,
-...
 .8877486253586
     };
     /*
      * Calculates the ratio between the frequency of the midi note passed as argument and middle C note ( MIDI value = 60 ).
      * This is used for pitch shifting the granular synth output, according to the key pressed by the user.
      * The middle C is taken as reference in pitch in the pitch shifting of Collidoscope output.
      * That is, with the middle C the output is not pitch shifted at all and is equal in frequency to the recorder sample.
+     *
      */
     inline double calculateMidiNoteRatio( int midiNote )
+    {
         int distanceFromCenter = midiNote - 60; // 60 is the central midi note
-...
         /* audio context */
         auto ctx = Context::master();
         /* audio input device */
         /* audio inpu 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 from one channel route to one channel buffer recorder
             // route the input part of the audio graph. Two channels input goes into
             // one channel route and 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 as the loop corresponds to no midi note
             // use -1 as ID
             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 oscilloscope as well
             // what goes to output goes to scope
             mLowPassFilterNodes[chan] >> mOutputMonitorNodes[chan];
+        }
-...
         return mBufferRecorderNodes[waveIdx]->getRingBuffer().getAvailableRead();
+    }
     bool AudioEngine::readRecordWave( size_t waveIdx, RecordWaveMsg* buffer, size_t count )
+    {
         return mBufferRecorderNodes[waveIdx]->getRingBuffer().read( buffer, count );

     /*
      Copyright (C) 2016  Queen Mary University of London
      Author: Fiore Martin
      This file is part of Collidoscope.
      Collidoscope is free software: you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
      This program is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
      GNU General Public License for more details.
      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:
         Copyright (c) 2014, The Cinder Project
         This code is intended to be used with the Cinder C++ library, http://libcinder.org
         Redistribution and use in source and binary forms, with or without modification, are permitted provided that
         the following conditions are met:
         * Redistributions of source code must retain the above copyright notice, this list of conditions and
         the following disclaimer.
         * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and
         the following disclaimer in the documentation and/or other materials provided with the distribution.
         THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
         WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
         PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
         ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
         TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
         HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
         NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
         POSSIBILITY OF SUCH DAMAGE.
     */
     #include "BufferToWaveRecorderNode.h"
     #include "cinder/audio/Context.h"
     #include "cinder/audio/Target.h"

     /*
      Copyright (C) 2015  Fiore Martin
      Copyright (C) 2016  Queen Mary University of London
      Author: Fiore Martin
      This file is part of Collidoscope.
      Collidoscope is free software: you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
      This program is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
      GNU General Public License for more details.
      You should have received a copy of the GNU General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
     */
     #include "Chunk.h"
     #include "DrawInfo.h"
-...
     void Chunk::update( const DrawInfo &di )
+    {
         using namespace ci;
         /* if resetting animate the chunks to nicely shrink to 0 size */
         /* if resetting animate the chunks to shrink to 0 size */
         if ( mResetting ){
             if ( mAnimate > 0.0f ){
                 mAnimate -= 0.1f;
-...
+            }
+        }
         mX = di.flipX( 1 + (mIndex * (2 + kWidth)) ); // FIXME more efficient if it happens only once when resized
         mX = di.flipX( 1 + (mIndex * (2 + kWidth)) ); // FIXME this should happen only once when resized
+    }
     void Chunk::draw( const DrawInfo& di, ci::gl::BatchRef &batch ){
         using namespace ci;
         gl::pushModelMatrix();
         const float chunkHeight = mAnimate * mAudioTop * di.getMaxChunkHeight();
         // place the chunk in the right position brings back the y of chunkHeight/2 so
         // place the chunk in the right position brigns 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();
-...
     void Chunk::drawBar( const DrawInfo& di, ci::gl::BatchRef &batch ){
         using namespace ci;
     	using namespace ci;
         gl::pushModelMatrix();
-...
     const float Chunk::kWidth = 7.0f;
     const float Chunk::kHalfWidth = 3.5f;
     const float Chunk::kHalfWidth = 3.5f;

     /*
      Copyright (C) 2016  Queen Mary University of London
      Author: Fiore Martin
      This file is part of Collidoscope.
      Collidoscope is free software: you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
      This program is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
      GNU General Public License for more details.
      You should have received a copy of the GNU General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
     */
     #include "cinder/app/App.h"
     #include "cinder/app/RendererGl.h"
     #include "cinder/gl/gl.h"
     #include "cinder/Exception.h"
     #include <stdexcept>
     #include "Config.h"
-...
     class CollidoscopeApp : public App {
       public:
         void setup() override;
     	void setup() override;
         void setupGraphics();
         /** Receives MIDI command messages from MIDI thread */
         void receiveCommands();
         /** Prints command line usage */
         void usage();
         void keyDown( KeyEvent event ) override;
         void update() override;
         void draw() override;
     	void keyDown( KeyEvent event ) override;
     	void update() override;
     	void draw() override;
         void resize() override;
         Config mConfig;
     	Config mConfig;
         collidoscope::MIDI mMIDI;
         AudioEngine mAudioEngine;
         array< shared_ptr< Wave >, NUM_WAVES > mWaves;
         array< shared_ptr< DrawInfo >, NUM_WAVES > mDrawInfos;
         array< shared_ptr< Oscilloscope >, NUM_WAVES > mOscilloscopes;
         // buffer to read the WAVE_* messages as a new wave gets recorded
         // buffers 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;
-...
+    {
         char c = event.getChar();
         const size_t waveIdx = 0;
         switch (c){
         case 'r' :
             mAudioEngine.record( waveIdx );
             mAudioEngine.record( 0 );
             mAudioEngine.record( 1 );
             break;
         case 'w': {
             mWaves[0]->getSelection().setSize(mWaves[0]->getSelection().getSize() + 1);
             mWaves[waveIdx]->getSelection().setSize(mWaves[waveIdx]->getSelection().getSize() + 1);
             size_t numSelectionChunks = mWaves[waveIdx]->getSelection().getSize();
             size_t numSelectionChunks = mWaves[0]->getSelection().getSize();
             // how many samples in one selection ?
             size_t selectionSize = numSelectionChunks * (mConfig.getWaveLen() * mAudioEngine.getSampleRate() / mConfig.getNumChunks());
             mAudioEngine.setSelectionSize(waveIdx, selectionSize);
             mAudioEngine.setSelectionSize(0, selectionSize);
         };
             break;
         case 'e': {
             mWaves[1]->getSelection().setSize(mWaves[1]->getSelection().getSize() + 1);
             size_t numSelectionChunks = mWaves[1]->getSelection().getSize();
             // how many samples in one selection ?
             size_t selectionSize = numSelectionChunks * (mConfig.getWaveLen() * mAudioEngine.getSampleRate() / mConfig.getNumChunks());
             mAudioEngine.setSelectionSize(1, selectionSize);
         };
             break;
         case 's': {
             mWaves[waveIdx]->getSelection().setSize( mWaves[waveIdx]->getSelection().getSize() - 1 );
             mWaves[0]->getSelection().setSize( mWaves[0]->getSelection().getSize() - 1 );
             size_t selectionSize = mWaves[waveIdx]->getSelection().getSize() *(mConfig.getWaveLen() * mAudioEngine.getSampleRate() / mConfig.getNumChunks());
             mAudioEngine.setSelectionSize( waveIdx, selectionSize );
             size_t selectionSize = mWaves[0]->getSelection().getSize() *(mConfig.getWaveLen() * mAudioEngine.getSampleRate() / mConfig.getNumChunks());
             mAudioEngine.setSelectionSize( 0, selectionSize );
         };
             break;
         case 'd': {
             size_t selectionStart = mWaves[waveIdx]->getSelection().getStart();
             mWaves[waveIdx]->getSelection().setStart( selectionStart + 1 );
             for( size_t waveIdx = 0; waveIdx < NUM_WAVES; waveIdx++){
                 size_t selectionStart = mWaves[waveIdx]->getSelection().getStart();
                 mWaves[waveIdx]->getSelection().setStart( selectionStart + 1 );
             selectionStart = mWaves[waveIdx]->getSelection().getStart();
             mAudioEngine.setSelectionStart( waveIdx, selectionStart * (mConfig.getWaveLen() * mAudioEngine.getSampleRate() / mConfig.getNumChunks()) );
                 selectionStart = mWaves[waveIdx]->getSelection().getStart();
                 mAudioEngine.setSelectionStart( waveIdx, selectionStart * (mConfig.getWaveLen() * mAudioEngine.getSampleRate() / mConfig.getNumChunks()) );
+            }
         };
             break;
         case 'a': {
             size_t selectionStart = mWaves[waveIdx]->getSelection().getStart();
             size_t selectionStart = mWaves[0]->getSelection().getStart();
             if ( selectionStart == 0 )
                 return;
             mWaves[waveIdx]->getSelection().setStart( selectionStart - 1 );
             mWaves[0]->getSelection().setStart( selectionStart - 1 );
             selectionStart = mWaves[waveIdx]->getSelection().getStart();
             selectionStart = mWaves[0]->getSelection().getStart();
             mAudioEngine.setSelectionStart( waveIdx, selectionStart * (mConfig.getWaveLen() * mAudioEngine.getSampleRate() / mConfig.getNumChunks()) );
             mAudioEngine.setSelectionStart( 0, selectionStart * (mConfig.getWaveLen() * mAudioEngine.getSampleRate() / mConfig.getNumChunks()) );
         };
             break;
         case 'p':
             mWaves[0]->setCursorPos(  4, mWaves[0]->getSelection().getStart(), *mDrawInfos[0] ) ;
             break;
         case 'f':
             setFullScreen( !isFullScreen() );
             break;
-...
             static bool isOn = false;
             isOn = !isOn;
             if ( isOn ){
                 mAudioEngine.loopOn( waveIdx );
                 mAudioEngine.loopOn( 0 );
                 mAudioEngine.loopOn( 1 );
+            }
             else{
                 mAudioEngine.loopOff( waveIdx );
                 mAudioEngine.loopOff( 0 );
                 mAudioEngine.loopOff( 1 );
+            }
         };
             break;
     	case 'm' :
     		mAudioEngine.setGrainDurationCoeff(0, 8);
     		break;
         case 'n': {
             mAudioEngine.setGrainDurationCoeff( 0, 1 );
         };
             break;
         case '9': {
             int c = mWaves[waveIdx]->getSelection().getParticleSpread();
             int c = mWaves[0]->getSelection().getParticleSpread();
             if ( c == 1 )
                 return;
             else
                 c -= 1;
             mAudioEngine.setGrainDurationCoeff( waveIdx, c );
             mWaves[waveIdx]->getSelection().setParticleSpread( float( c ) );
             mAudioEngine.setGrainDurationCoeff( 0, c );
             mWaves[0]->getSelection().setParticleSpread( float( c ) );
             mAudioEngine.setGrainDurationCoeff( 1, c );
             mWaves[1]->getSelection().setParticleSpread( float( c ) );
         }; break;
         case '0': {
             int c = mWaves[waveIdx]->getSelection().getParticleSpread();
             int c = mWaves[0]->getSelection().getParticleSpread();
             if ( c == 8 )
                 return;
             else
                 c += 1;
             mAudioEngine.setGrainDurationCoeff( waveIdx, c );
             mWaves[waveIdx]->getSelection().setParticleSpread( float( c ) );
             mAudioEngine.setGrainDurationCoeff( 0, c );
             mWaves[0]->getSelection().setParticleSpread( float( c ) );
         }; break;
+        }
+    }
-...
     void CollidoscopeApp::draw()
+    {
         gl::clear( Color( 0, 0, 0 ) );
     	gl::clear( Color( 0, 0, 0 ) );
         for ( int i = 0; i < NUM_WAVES; i++ ){
             if ( i == 1 ){
-...
                 value |= MSB;
                 // value ranges from 0 to 149. check boundaries in case sensor gives bad values
                 if ( value > 149 ){ // FIXME can use wave.size()
                 // value ranges from 0 to 1050. check boundaries in case sensor gives bad values
                 if ( value > 149 ){ // FIXME pareametrizer
                     continue;
+                }
-...
                     mWaves[waveIdx]->getSelection().setSize( numSelectionChunks );
                     // how many samples in one selection ?
                     size_t selectionSize = mWaves[waveIdx]->getSelection().getSize() * (mConfig.getWaveLen() * mAudioEngine.getSampleRate() / mConfig.getNumChunks());
     				size_t selectionSize = mWaves[waveIdx]->getSelection().getSize() * (mConfig.getWaveLen() * mAudioEngine.getSampleRate() / mConfig.getNumChunks());
                     mAudioEngine.setSelectionSize( waveIdx, selectionSize );
                 };
-...
+        }
+    }
     CINDER_APP( CollidoscopeApp, RendererGl, [] ( App::Settings *settings) {
         const std::vector< string > args = settings->getCommandLineArgs();
         int width = 0;
         int height = 0;
         try {
             if( args.size() != 3 )
                 throw std::invalid_argument("");
             width  = std::stoi( args[1] );
             height = std::stoi( args[2] );
+        }
         catch( std::invalid_argument & e ){
             console() << "Error: invalid arguments" << std::endl;
             console() << "Usage: ./CollidoscopeApp window_width window_height" << std::endl;
             console() << "For example: ./CollidoscopeApp 1024 768 " << std::endl;
             settings->setShouldQuit( true );
             return;
+        }
         settings->setWindowSize( width, height );
         settings->setMultiTouchEnabled( false );
         settings->disableFrameRate();
             settings->setWindowSize( 1920, 1080 );
             settings->setMultiTouchEnabled( false );
             settings->disableFrameRate();
     } )

     /*
      Copyright (C) 2016  Queen Mary University of London
      Author: Fiore Martin
      This file is part of Collidoscope.
      Collidoscope is free software: you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
      This program is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
      GNU General Public License for more details.
      You should have received a copy of the GNU General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
     */
     #include "Config.h"
-...
+    }
     // uses Cinder api to parse configuration in XML file
     void Config::loadFromFile( std::string&& path )
+    {
         try {

     /*
      Copyright (C) 2016  Queen Mary University of London
      Author: Fiore Martin
      This file is part of Collidoscope.
      Collidoscope is free software: you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
      This program is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
      GNU General Public License for more details.
      You should have received a copy of the GNU General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
     */
     #include "cinder/Log.h"

     /*
      Copyright (C) 2016  Queen Mary University of London
      Author: Fiore Martin
      This file is part of Collidoscope.
      Collidoscope is free software: you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
      This program is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
      GNU General Public License for more details.
      You should have received a copy of the GNU General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
     */
     #include "MIDI.h"
     #include "Config.h"
-...
         msg.mData2 = (numBytes == 3 ? (*rtMidiMessage)[2] : 0);
         return msg;
+    }
+    }

     /*
      Copyright (C) 2016  Queen Mary University of London
      Author: Fiore Martin
      This file is part of Collidoscope.
      Collidoscope is free software: you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
      This program is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
      GNU General Public License for more details.
      You should have received a copy of the GNU General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
     */
     #include "PGranularNode.h"
     #include "cinder/audio/Context.h"
-...
+    {
         mTempBuffer = std::make_shared< ci::audio::Buffer >( getFramesPerBlock() );
         mRandomOffset.reset( new RandomGenerator( getSampleRate() / 100 ) ); // divided by 100 corresponds to multiplied by 0.01 in the time domain
         mRandomOffset.reset( new RandomGenerator( getSampleRate() / 100 ) ); // divided by 100 corresponds to times 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 ) );
-...
     void PGranularNode::process (ci::audio::Buffer *buffer )
+    {
         // only update PGranular if the atomic value has changed from the previous time
         const boost::optional<size_t> selectionSize = mSelectionSize.get();
         if ( selectionSize ){
             mPGranularLoop->setSelectionSize( *selectionSize );
-...
+        }
+    }
     // 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 voice
                 // then look for a free synth
                 for ( int i = 0; i < kMaxVoices; i++ ){
                     if ( mMidiNotes[i] == kNoMidiNote ){

     /*
      Copyright (C) 2015  Fiore Martin
      Copyright (C) 2016  Queen Mary University of London
      Author: Fiore Martin
      This file is part of Collidoscope.
      Collidoscope is free software: you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
      This program is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
      GNU General Public License for more details.
      You should have received a copy of the GNU General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
     */
     #include "ParticleController.h"
     #include "cinder/Rand.h"
-...
     mNumParticles( 0 )
+    {
         // uses Cinder (and OpenGL) drawing based on virtual buffer object
         // see ParticleSphereCPU example in Cinder library
         mParticles.assign( kMaxParticles, Particle() );
         mParticlePositions.assign( kMaxParticles, vec2( -1, -1 ) );
-...
         auto mesh = gl::VboMesh::create( mParticlePositions.size(), GL_POINTS, { { particleLayout, mParticleVbo } } );
         // creates glsl program to run the batch with
     #if ! defined( CINDER_GL_ES )
         auto glsl = gl::GlslProg::create( gl::GlslProg::Format()
             .vertex( CI_GLSL( 150,
-...
     void ParticleController::updateParticles()
+    {
         // 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];
-...
+            }
+        }
         // Copy particle data onto the GPU.
     	// Map the GPU memory and write over it.
         void *gpuMem = mParticleVbo->mapReplace();
         memcpy( gpuMem, mParticlePositions.data(), mParticlePositions.size() * sizeof( vec2 ) );
         mParticleVbo->unmap();
-...
     void ParticleController::addParticles(int amount, const vec2 &initialLocation, const float cloudSize)
+    {
         // 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;
         if ( mNumParticles + amount > kMaxParticles ){
     		//a.k.a. return if reached kMaxParticles
     		//return;
             amount = kMaxParticles - mNumParticles;
+    	}

     /*
      Copyright (C) 2015  Fiore Martin
      Copyright (C) 2016  Queen Mary University of London
      Author: Fiore Martin
      This file is part of Collidoscope.
      Collidoscope is free software: you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
      This program is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
      GNU General Public License for more details.
      You should have received a copy of the GNU General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
     */
     #include "Wave.h"
     #include "DrawInfo.h"
-...
     Wave::Wave( size_t numChunks, Color selectionColor ):
         mNumChunks( numChunks ),
         mSelection( this, selectionColor ),
         mColor(Color(0.5f, 0.5f, 0.5f)),
     	mSelection( this, selectionColor ),
     	mColor(Color(0.5f, 0.5f, 0.5f)),
         mFilterCoeff( 1.0f )
+    {
         mChunks.reserve( numChunks );
     	mChunks.reserve( numChunks );
         for ( size_t i = 0; i < numChunks; i++ ){
             mChunks.emplace_back( i );
+        }
     	for ( size_t i = 0; i < numChunks; i++ ){
     		mChunks.emplace_back( i );
+    	}
         // init cinder batch drawing
         auto lambert = gl::ShaderDef().color();
         gl::GlslProgRef shader = gl::getStockShader( lambert );
         mChunkBatch = gl::Batch::create( geom::Rect( ci::Rectf( 0, 0, Chunk::kWidth, 1 ) ), shader );
-...
     void Wave::reset( bool onlyChunks )
+    {
         for (size_t i = 0; i < getSize(); i++){
             mChunks[i].reset();
+        }
     	for (size_t i = 0; i < getSize(); i++){
     		mChunks[i].reset();
+    	}
         if (onlyChunks)
             return;
     	if (onlyChunks)
     		return;
         mSelection.setToNull();
     	mSelection.setToNull();
+    }
     void Wave::setChunk(size_t index, float bottom, float top)
+    {
         Chunk &c = mChunks[index];
         c.setTop(top);
         c.setBottom(bottom);
     	Chunk &c = mChunks[index];
     	c.setTop(top);
     	c.setBottom(bottom);
+    }
     inline const Chunk & Wave::getChunk(size_t index)
+    {
         return mChunks[index];
     	return mChunks[index];
+    }
     void Wave::update( double secondsPerChunk, const DrawInfo& di ) {
-...
             double elapsed = now - itr->second.lastUpdate;
             // 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
             /* check we don't go too far off */
             if (itr->second.pos > mSelection.getEnd()){
                 itr->second.pos = Cursor::kNoPosition;
+            }
-...
     void Wave::draw( const DrawInfo& di ){
         /* ########### draw the particles ########## */
     	/* ########### draw the particles ########## */
     #ifdef USE_PARTICLES
         mParticleController.draw();
     	mParticleController.draw();
     #endif
         /* ########### draw the wave ########## */
         /* scale the wave to fit the window */
         gl::pushModelView();
     	/* ########### draw the wave ########## */
     	/* scale the wave to fit the window */
     	gl::pushModelView();
         const float wavePixelLen =  ( mNumChunks * ( 2 + Chunk::kWidth ) );
         /* scale the x-axis for the wave to fit the window precisely */
         gl::scale( ((float)di.getWindowWidth() ) / wavePixelLen , 1.0f);
         /* draw the chunks */
         if (mSelection.isNull()){
             /* no selection: all chunks the same color */
             gl::color(mColor);
             for (size_t i = 0; i < getSize(); i++){
                 mChunks[i].draw( di, mChunkBatch );
+            }
+        }
     	const float wavePixelLen =  ( mNumChunks * ( 2 + Chunk::kWidth ) );
     	/* scale the x-axis for the wave to fit the window */
     	gl::scale( ((float)di.getWindowWidth() ) / wavePixelLen , 1.0f);
     	/* draw the chunks */
     	if (mSelection.isNull()){
     		/* no selection: all chunks the same color */
     		gl::color(mColor);
     		for (size_t i = 0; i < getSize(); i++){
     			mChunks[i].draw( di, mChunkBatch );
+    		}
+    	}
         else{
             // Selection not null
             gl::color(this->mColor);
     		gl::color(this->mColor);
             // update the array with cursor positions
             mCursorsPos.clear();
-...
                 mCursorsPos.push_back( cursor.second.pos );
+            }
             gl::enableAlphaBlending();
     		gl::enableAlphaBlending();
             const float selectionAlpha = 0.5f + mFilterCoeff * 0.5f;
     		const float selectionAlpha = 0.5f + mFilterCoeff * 0.5f;
             for (size_t i = 0; i < getSize(); i++){
                 /* when in selection use selection color */
                 if (i == mSelection.getStart()){
                     /* draw the selection bar with a transparent selection color */
                     gl::color(mSelection.getColor().r, mSelection.getColor().g, mSelection.getColor().b, 0.5f);
     		for (size_t i = 0; i < getSize(); i++){
     			/* when in selection use selection color */
     			if (i == mSelection.getStart()){
     				/* 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 color to the selection */
                     gl::color(mSelection.getColor().r, mSelection.getColor().g, mSelection.getColor().b, selectionAlpha);
+                }
     				/* set the color to the selection */
     				gl::color(mSelection.getColor().r, mSelection.getColor().g, mSelection.getColor().b, selectionAlpha);
+    			}
                 // 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 );
                     gl::color(mSelection.getColor().r, mSelection.getColor().g, mSelection.getColor().b, selectionAlpha);
+                }
                 else{
                     /* just draw with current color */
                     mChunks[i].draw( di, mChunkBatch );
+                }
                 /* exit selection: go back to wave color */
                 if (i == mSelection.getEnd()){
                     /* draw the selection bar with a transparent selection color */
                     gl::color(mSelection.getColor().r, mSelection.getColor().g, mSelection.getColor().b, 0.5f);
                 // check if one of the cursors is positioned in this chunk
     			if (std::find(mCursorsPos.begin(), mCursorsPos.end(),i) != mCursorsPos.end() ){
     				gl::color(CURSOR_CLR);
     				mChunks[i].draw( di, mChunkBatch );
     				gl::color(mSelection.getColor().r, mSelection.getColor().g, mSelection.getColor().b, selectionAlpha);
+    			}
     			else{
     				/* just draw with current color */
     				mChunks[i].draw( di, mChunkBatch );
+    			}
     			/* exit selection: go back to wave color */
     			if (i == mSelection.getEnd()){
     				/* 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 color to the wave */
                     gl::color(this->mColor);
+                }
+            }
             gl::disableAlphaBlending();
+        }
     				/* set the colo to the wave */
     				gl::color(this->mColor);
+    			}
+    		}
     		gl::disableAlphaBlending();
+    	}
         gl::popModelView();
     	gl::popModelView();
+    }
-...
     void Wave::Selection::setStart(size_t start)  {
         /* deselect the previous */
     	/* deselect the previous */
         mWave->mChunks[mSelectionStart].setAsSelectionStart( false );
         /* select the next */
     	/* select the next */
         mWave->mChunks[start].setAsSelectionStart( true );
         mNull = false;
     	mNull = false;
         size_t size = getSize();
         mSelectionStart = start;
     	mSelectionStart = start;
         mSelectionEnd = start + size - 1;
         if ( mSelectionEnd > mWave->getSize() - 1 )
             mSelectionEnd = mWave->getSize() - 1;
-...
             size = mWave->mNumChunks - mSelectionStart - 1;
+        }
         /* deselect the previous */
     	/* deselect the previous */
         mWave->mChunks[mSelectionEnd].setAsSelectionEnd( false );
         mSelectionEnd = mSelectionStart + size;
         /* select the next */
     	/* select the next */
         mWave->mChunks[mSelectionEnd].setAsSelectionEnd( true );
         mNull = false;
     	mNull = false;
+    }

Collidoscope

Revision 0:02467299402e CollidoscopeApp/src