/CollidoscopeApp - 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/>.
     */
     #pragma once
     #include <array>

     /*
      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.
     */
     #pragma once
     #include "cinder/Cinder.h"
-...
     #include "Messages.h"
     typedef std::shared_ptr<class BufferToWaveRecorderNode>	BufferToWaveRecorderNodeRef;
     typedef std::shared_ptr<class BufferToWaveRecorderNode> BufferToWaveRecorderNodeRef;
     typedef ci::audio::dsp::RingBufferT<RecordWaveMsg> RecordWaveMsgRingBuffer;
-...
         void setNumSeconds(double numSeconds, bool shrinkToFit = false);
         //! Returns the length of the recording buffer in frames.
         size_t		getNumFrames() const	{ return mRecorderBuffer.getNumFrames(); }
         size_t      getNumFrames() const    { return mRecorderBuffer.getNumFrames(); }
         //! Returns the length of the recording buffer in seconds.
         double		getNumSeconds() const;
         double      getNumSeconds() const;
         //! \brief Returns a copy of the recored samples, up to the current write position.
         //!
         //! This method is non locking, and as such any resizing calls must be performed on the same thread or be otherwise synchronized.
         ci::audio::BufferRef	getRecordedCopy() const;
         ci::audio::BufferRef    getRecordedCopy() const;
         //! \brief Writes the currently recorded samples to a file at \a filePath
         //!
-...
     protected:
         void initialize()				override;
         void process(ci::audio::Buffer *buffer)	override;
         void initialize()               override;
         void process(ci::audio::Buffer *buffer) override;
         void initBuffers(size_t numFrames);
         static const float kMinAudioVal;
         static const float kMaxAudioVal;
         ci::audio::BufferDynamic		mRecorderBuffer;
         ci::audio::BufferDynamicRef		mCopiedBuffer;
         std::atomic<uint64_t>	mLastOverrun;
         ci::audio::BufferDynamic        mRecorderBuffer;
         ci::audio::BufferDynamicRef     mCopiedBuffer;
         std::atomic<uint64_t>   mLastOverrun;
         RecordWaveMsgRingBuffer mRingBuffer;

     /*
      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/>.
     */
     #pragma once
-...
         /**
          * Constructor, takes as argument the index of this chunk in the wave
          */
     	Chunk( size_t index );
         Chunk( size_t index );
         /**
          * Sets the top value of this chunk. The value is passed in audio coordinates : [-1.0, 1.0]
-...
          * Reset this chunks. When a chunk is reset it starts shrinking until it disappears.
+         *
          */
     	void reset(){
     		mResetting = true;
+    	}
         void reset(){
             mResetting = true;
+        }
         /**
          * Called in the graphic loop. It update this chunk.
-...
         /**
          * Informs this chunk that it's the first chunk of the selection.
          */
     	void setAsSelectionStart(bool start){
     		isSelectionStart = start;
+    	}
         void setAsSelectionStart(bool start){
             isSelectionStart = start;
+        }
         /**
          * Informs this chunk that it's the last chunk of the selection.
          */
     	void setAsSelectionEnd(bool end){
     		isSelectionEnd = end;
+    	}
         void setAsSelectionEnd(bool end){
             isSelectionEnd = end;
+        }
     private:

     /*
      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/>.
     */
     #pragma once
     #include <string>

     /*
      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/>.
     */
     #pragma once
     #include "cinder/Area.h"
-...
          * Maps a value in the audio space [-1.0, 1.0] to a position on the y axis of this DrawInf's bounding area.
+         *
          */
     	float audioToHeigt(float audioSample) const {
         float audioToHeigt(float audioSample) const {
             /* clip into range [-1.1] */
             if (audioSample < -1.0f) {
                 audioSample = -1.0f;
-...
+            }
             /* map from [-1,1] to [0,1] */
     		float ratio = (audioSample - (-1.0f)) * 0.5f; // 2 = 1 - (-1)
             float ratio = (audioSample - (-1.0f)) * 0.5f; // 2 = 1 - (-1)
     		/* get bottom and add the scaled height */
             /* get bottom and add the scaled height */
             return ratio * mSelectionBarHeight; //remove  bounds.getY1() bound only needed for size of tier
+    	}
+        }
         float getMaxChunkHeight() const
+        {
-...
         /**
          * 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.
          */
     	int flipY(int y) const
         int flipY(int y) const
+        {
             if ( mWaveIndex == 0)
     		    return mWindowHeight - y;
                 return mWindowHeight - y;
             else
                 return y;
+    	}
+        }
         /**
          * Returns x. not used at he moment.
+         *
          */
     	int flipX(int x) const
         int flipX(int x) const
+        {
             return x;
+    	}
+        }
         // how much the wave is shrunk on the y axis with respect to the wave's tier

     /*
      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/>.
     */
     #pragma once
     namespace 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/>.
     */
     #pragma once

     /*
      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/>.
     */
     #pragma once
     #include "RtMidi.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/>.
     */
     #pragma once
     /**

     /*
      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/>.
     */
     #pragma once
     #include "cinder/gl/gl.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/>.
     */
     #pragma once
     #include <array>

     /*
      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/>.
     */
     #pragma once
     #include "cinder/Cinder.h"
-...
     protected:
         void initialize()							override;
         void initialize()                           override;
         void process( ci::audio::Buffer *buffer )	override;
         void process( ci::audio::Buffer *buffer )   override;
     private:

     /*
      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/>.
     */
     #pragma once
     #include "cinder/gl/gl.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/>.
     */
     #pragma once
     #include "cinder/CinderResources.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/>.
     */
     #pragma once
     #include "cinder/audio/dsp/RingBuffer.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/>.
     */
     #pragma once
-...
      */
     class Wave
+    {
     	friend class ParticleController;
         friend class ParticleController;
     public:
-...
          * The selection of the wave that is controlled by the big horizontal knob
+         *
          */
     	class Selection {
     	public:
         class Selection {
         public:
             Selection( Wave * w, Color color );
-...
             void setStart( size_t start );
             /** Sets the size of selection. size is the number of chunks the selection is made of */
     		void setSize( size_t size );
             void setSize( size_t size );
             /** Particle spread is used to calculate the size of the cloud of particles */
             void inline setParticleSpread( float spread ){
                 mParticleSpread = spread;
+    		}
+            }
     		size_t getStart(void) const { return mSelectionStart; }
             size_t getStart(void) const { return mSelectionStart; }
             size_t getEnd(void) const { return mSelectionEnd; }
     		size_t inline getSize(void) const {
     			if (mNull)
     				return 0;
     			else
     				return 1 + mSelectionEnd - mSelectionStart;
+    		}
             size_t inline getSize(void) const {
                 if (mNull)
                     return 0;
                 else
                     return 1 + mSelectionEnd - mSelectionStart;
+            }
     		float inline  getParticleSpread() const { return mParticleSpread; }
             float inline  getParticleSpread() const { return mParticleSpread; }
             /** When selection is null no selection is showed on the wave */
     		inline void setToNull(){
             inline void setToNull(){
                 mParticleSpread = 1.0f;
     			mNull = true;
+    		}
                 mNull = true;
+            }
     		inline bool isNull() const{
     			return mNull;
+    		}
             inline bool isNull() const{
                 return mNull;
+            }
     		inline const Color & getColor() const{
     			return mColor;
+    		}
             inline const Color & getColor() const{
                 return mColor;
+            }
         private:
-...
             Wave * mWave;
     	}; // class Selection
         }; // class Selection
     #ifdef USE_PARTICLES
     	ParticleController mParticleController;
         ParticleController mParticleController;
     #endif
     	/* Maps id of the synth to cursor. There is one cursor for each Synth being played */
     	std::map < SynthID, Cursor > mCursors;
         /* 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 */
     	std::vector<int> mCursorsPos;
         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;
         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;
         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
          *  \param onlyChunks if false the selection is also set to null, if true only the chunks are reset
          */
     	void reset(bool onlyChunks);
         void reset(bool onlyChunks);
         /** sets top and bottom values for the chunk.
          * \a bottom and \a top are in audio coordinates [-1.0, 1.0]
          */
     	void setChunk(size_t index, float bottom, float top);
         void setChunk(size_t index, float bottom, float top);
     	const Chunk & getChunk(size_t index);
         const Chunk & getChunk(size_t index);
         /** 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 & cursor = mCursors[id];
     	    cursor.pos = pos;
     	    cursor.lastUpdate = ci::app::getElapsedSeconds();
             Cursor & cursor = mCursors[id];
             cursor.pos = pos;
             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
     	    if (mSelection.getParticleSpread() > 1.0f){
     		    /* amountCoeff ranges from 1/8 to 1 */
             // 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 */
-...
                 centrePoint.y = di.flipY( di.audioToHeigt(0.0) );
                 const float wavePixelLen = mNumChunks * ( 2 + Chunk::kWidth);
     		    centrePoint.x *= float(di.getWindowWidth()) / wavePixelLen;
                 centrePoint.x *= float(di.getWindowWidth()) / wavePixelLen;
     		    mParticleController.addParticles(
                 mParticleController.addParticles(
                     std::max( 1, (int)(amountCoeff * ParticleController::kMaxParticleAdd * mFilterCoeff) ), // amount of particles to add
     			    centrePoint,
                     centrePoint,
                     mSelection.getParticleSpread() * PARTICLESIZE_COEFF   // size of the cloud
     			    );
+    	    }
                     );
+            }
     #endif
+    	}
+        }
         void update( double secondsPerChunk, const DrawInfo& di );
         void removeCursor( SynthID id ) { mCursors.erase( id ); }
         /** Sets the transparency of this wave. \a alpha ranges from 0 to 1 */
     	inline void setselectionAlpha(float alpha){ mFilterCoeff = alpha;}
         inline void setselectionAlpha(float alpha){ mFilterCoeff = alpha;}
         void draw( const DrawInfo& di );
     	Selection& getSelection() { return mSelection; };
         Selection& getSelection() { return mSelection; };
     	size_t getSize() const{ return mChunks.size();  }
         size_t getSize() const{ return mChunks.size();  }
     	void setScopePoint(int index, float audioVal);
         void setScopePoint(int index, float audioVal);
         Wave( size_t numChunks, Color selectionColor );

     /*
      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"
     #include "cinder/app/App.h"
     //FIXME remove App.h include

     /*
      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::draw( const DrawInfo& di, ci::gl::BatchRef &batch ){
         using namespace ci;
         gl::pushModelMatrix();
         const float chunkHeight = mAnimate * mAudioTop * di.getMaxChunkHeight();
-...
     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"
-...
     class CollidoscopeApp : public App {
       public:
     	void setup() override;
         void setup() override;
         void setupGraphics();
         void receiveCommands();
     	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;
-...
         };
             break;
     	case 'm' :
     		mAudioEngine.setGrainDurationCoeff(0, 8);
     		break;
         case 'm' :
             mAudioEngine.setGrainDurationCoeff(0, 8);
             break;
         case 'n': {
             mAudioEngine.setGrainDurationCoeff( 0, 1 );
-...
     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 ){
-...
                     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 );
                 };

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

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

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

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

     /*
      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();
-...
     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 ) {
-...
     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 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 );
+            }
+        }
         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
     			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);
                 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 colo 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 5:75b744078d66 CollidoscopeApp