annotate CollidoscopeApp/src/ParticleController.cpp @ 18:f1ff1a81be20 tip

Changed licenses names.
Fixed one comment and usage text in CollidoscopeApp.cpp.

/*

 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"

#include <type_traits>

using namespace ci;
using std::list;

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

    mParticleVbo = gl::Vbo::create( GL_ARRAY_BUFFER, mParticlePositions, GL_DYNAMIC_DRAW );

    geom::BufferLayout particleLayout;
    particleLayout.append( geom::Attrib::POSITION, 2, sizeof( vec2 ), 0 );

    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,
            uniform mat4	ciModelViewProjection;
            in vec4			ciPosition;

            void main( void ) {
                gl_Position = ciModelViewProjection * ciPosition;
                gl_PointSize = 1.0;
            }
            ) )
        .fragment( CI_GLSL( 150,
            out vec4 oColor;

            void main( void ) {
                oColor = vec4( 1.0f, 1.0f, 1.0f, 1.0f );
            }
        ) )
    );

    mParticleBatch = gl::Batch::create( mesh, glsl );

#else
    auto glsl = gl::GlslProg::create( gl::GlslProg::Format()
        .vertex( CI_GLSL( 100,
            uniform mat4	ciModelViewProjection;
            attribute vec4			ciPosition;

            void main( void ) {
                gl_Position = ciModelViewProjection * ciPosition;
                gl_PointSize = 1.0;
            }
        ) )
        .fragment( CI_GLSL( 100,
            precision highp float;

            void main( void ) {
                gl_FragColor = vec4( 1, 1, 1, 1 );
            }
        ) ) 
    );

    mParticleBatch = gl::Batch::create( mesh, glsl );
#endif


}

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];
        vec2 &pos = mParticlePositions[i];

        particle.mAge++;


        if ( (!particle.mFlyOver && particle.mAge > particle.mLifespan) 
                || (particle.mFlyOver && particle.mAge >= 300) ){
            // dispose particle 
            mParticles[i] = mParticles[mNumParticles - 1];
            mParticlePositions[i] = mParticlePositions[mNumParticles - 1];
            mParticlePositions[mNumParticles - 1].x = -1.0f;
            mParticlePositions[mNumParticles - 1].y = -1.0f;
            mNumParticles--;
            continue;
        }

        pos += particle.mVel;
        if ( ci::distance( pos, particle.mCloudCenter ) >  particle.mCloudSize && !particle.mFlyOver ){
            particle.mVel = rotate<float>( particle.mVel, 5 );
        }
    }

    // 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 
        amount = kMaxParticles - mNumParticles;
	}

    if( amount <= 0 )
        return;

	for( size_t i = 0; i < amount; i++ ){
        // init new particle 
        Particle &particle = mParticles[mNumParticles + i];
        vec2 &pos = mParticlePositions[mNumParticles + i];

        pos = initialLocation + Rand::randVec2() * 5.0f; // find a location nearby the initial location
        particle.mCloudCenter = pos;
        particle.mVel = Rand::randVec2() * Rand::randFloat( 1.0f, 5.0f );
        particle.mCloudSize = cloudSize;
        particle.mAge = 0;
        particle.mLifespan = Rand::randInt( 30, 60 );
        particle.mFlyOver = (Rand::randInt( 500 ) == 0);
		
	}
    
    mNumParticles += amount ;

}