Collidoscope

#include "Wave.h"

#include "DrawInfo.h"

using namespace ci;

Wave::Wave( size_t numChunks, Color selectionColor ):

    mNumChunks( numChunks ),

        mSelection( this, selectionColor ),

        mColor(Color(0.5f, 0.5f, 0.5f)),

    mFilterCoeff( 1.0f )

{

        mChunks.reserve( numChunks );

        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();

        }

        if (onlyChunks)

                return;

        mSelection.setToNull();

}

void Wave::setChunk(size_t index, float bottom, float top)

{

        Chunk &c = mChunks[index];

        c.setTop(top);

        c.setBottom(bottom);

}

inline const Chunk & Wave::getChunk(size_t index)

{

        return mChunks[index];

}

void Wave::update( double secondsPerChunk, const DrawInfo& di ) {

    typedef std::map<int, Cursor>::iterator MapItr;

    // update the cursor positions

    double now = ci::app::getElapsedSeconds();

    for (MapItr itr = mCursors.begin(); itr != mCursors.end(); ++itr){

        if (mSelection.isNull()){

            itr->second.pos = Cursor::kNoPosition;

        }

        if ( itr->second.pos == Cursor::kNoPosition )

            continue;

        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

        itr->second.pos = mSelection.getStart() + int( elapsed / secondsPerChunk );

        // check we don't go too far off

        if (itr->second.pos > mSelection.getEnd()){

            itr->second.pos = Cursor::kNoPosition;

        }

    }

    // update chunks for animation

    for ( auto &chunk : mChunks ){

        chunk.update( di );

    }

#ifdef USE_PARTICLES

    mParticleController.updateParticles();

#endif

}

void Wave::draw( const DrawInfo& di ){

        /* ########### draw the particles ########## */

#ifdef USE_PARTICLES

        mParticleController.draw();

#endif

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

                }

        }

    else{

        // Selection not null

                gl::color(this->mColor);

        // update the array with cursor positions

        mCursorsPos.clear();

        for ( auto cursor : mCursors ){

            mCursorsPos.push_back( cursor.second.pos );

        }

                gl::enableAlphaBlending();

                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);

                mChunks[i].drawBar( di, mChunkBatch );

                                /* 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);

                mChunks[i].drawBar( di, mChunkBatch );

                                /* set the colo to the wave */

                                gl::color(this->mColor);

                        }

                }

                gl::disableAlphaBlending();

        }

        gl::popModelView();

}

//**************** Selection ***************//

Wave::Selection::Selection(Wave * w, Color color) :

    mWave( w ),

    mSelectionStart( 0 ),

    mSelectionEnd( 0 ),

    mColor( color ),

    mParticleSpread( 1 )

{}

void Wave::Selection::setStart(size_t start)  {

        /* deselect the previous */

    mWave->mChunks[mSelectionStart].setAsSelectionStart( false );

        /* select the next */

    mWave->mChunks[start].setAsSelectionStart( true );

        mNull = false;

    size_t size = getSize();

        mSelectionStart = start;

    mSelectionEnd = start + size - 1;

    if ( mSelectionEnd > mWave->getSize() - 1 )

        mSelectionEnd = mWave->getSize() - 1;

}

void Wave::Selection::setSize(size_t size)  {

    if ( size <= 0 ){

        mNull = true;

        return;

    }

    size -= 1;

    // check boundaries: size cannot bring the selection end beyond the end of the wave

    if ( mSelectionStart+size >= mWave->mNumChunks ){

        size = mWave->mNumChunks - mSelectionStart - 1;

    }

        /* deselect the previous */

    mWave->mChunks[mSelectionEnd].setAsSelectionEnd( false );

    mSelectionEnd = mSelectionStart + size;

        /* select the next */

    mWave->mChunks[mSelectionEnd].setAsSelectionEnd( true );

        mNull = false;

}

const cinder::Color Wave::CURSOR_CLR = Color(1.f, 1.f, 1.f);