/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield 
 *
 * This library is open source and may be redistributed and/or modified under  
 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or 
 * (at your option) any later version.  The full license is in LICENSE file
 * included with this distribution, and on the openscenegraph.org website.
 * 
 * This library 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 
 * OpenSceneGraph Public License for more details.
*/
//osgParticle - Copyright (C) 2002 Marco Jez

#ifndef OSGPARTICLE_PARTICLESYSTEMUPDATER
#define OSGPARTICLE_PARTICLESYSTEMUPDATER 1

#include <osgParticle/Export>
#include <osgParticle/ParticleSystem>

#include <vector>

#include <osg/ref_ptr>
#include <osg/CopyOp>
#include <osg/Object>
#include <osg/Node>
#include <osg/NodeVisitor>

#include <osgUtil/CullVisitor>

namespace osgParticle
{

    /**    A useful node class for updating particle systems automatically.
        When a ParticleSystemUpdater is traversed by a cull visitor, it calls the
        update() method on the specified particle systems. You should place this updater
        AFTER other nodes like emitters and programs.
    */
    class OSGPARTICLE_EXPORT ParticleSystemUpdater: public osg::Node {
    public:
        ParticleSystemUpdater();
        ParticleSystemUpdater(const ParticleSystemUpdater& copy, const osg::CopyOp& copyop = osg::CopyOp::SHALLOW_COPY);
        
        META_Node(osgParticle,ParticleSystemUpdater);
        
        /// Add a particle system to the list.
        inline bool addParticleSystem(ParticleSystem* ps);

        /// Remove a particle system from the list (by pointer).
        inline bool removeParticleSystem(ParticleSystem* ps);

        /// Remove a particle system(s) from the list (by index).
        inline bool removeParticleSystem(unsigned int i, unsigned int numParticleSystemsToRemove=1);
        
        /// Replace ParticleSystem with another ParticleSystem.
        inline bool replaceParticleSystem(ParticleSystem* origPS, ParticleSystem* newPS);

        /// set a particle system by index.
        inline bool setParticleSystem( unsigned int i, ParticleSystem* ps );

        /// Return the number of particle systems on the list.
        inline unsigned int getNumParticleSystems() const;

        /// Get a particle system from the list.
        inline ParticleSystem* getParticleSystem(unsigned int i);
        
        /// Get a particle system from the list.
        inline const ParticleSystem* getParticleSystem(unsigned int i) const;

        /// return true if ParticleSystem is contained within ParticlsSystemUpdater.
        inline bool containsParticleSystem( const ParticleSystem* ps ) const;

        /// get index number of ParticleSystem.
        inline unsigned int getParticleSystemIndex( const ParticleSystem* ps ) const;
        
        virtual void traverse(osg::NodeVisitor& nv);
        
        virtual osg::BoundingSphere computeBound() const;        

    protected:
        virtual ~ParticleSystemUpdater() {}
        ParticleSystemUpdater &operator=(const ParticleSystemUpdater &) { return *this; }
        
        
    private:
        typedef std::vector<osg::ref_ptr<ParticleSystem> > ParticleSystem_Vector;
        
        ParticleSystem_Vector _psv;
        double _t0;
        
        //added 1/17/06- bgandere@nps.edu
        //a var to keep from doing multiple updates per frame
        int _frameNumber; 
    };
    
    // INLINE FUNCTIONS
    
    inline bool ParticleSystemUpdater::addParticleSystem(ParticleSystem* ps)
    {
        _psv.push_back(ps);
        return true;
    }
    
    inline bool ParticleSystemUpdater::removeParticleSystem(ParticleSystem* ps)
    {
       unsigned int i = getParticleSystemIndex( ps );
       if( i >= _psv.size() ) return false;
       removeParticleSystem( i );
        return true;
    }

    inline bool ParticleSystemUpdater::removeParticleSystem(unsigned int pos, unsigned int numParticleSystemsToRemove)
    {
       if( (pos < _psv.size()) && (numParticleSystemsToRemove > 0) )
       {
          unsigned int endOfRemoveRange = pos + numParticleSystemsToRemove;
          if( endOfRemoveRange > _psv.size() )
          {
             osg::notify(osg::DEBUG_INFO)<<"Warning: ParticleSystem::removeParticleSystem(i,numParticleSystemsToRemove) has been passed an excessive number"<<std::endl;
             osg::notify(osg::DEBUG_INFO)<<"         of ParticleSystems to remove, trimming just to end of ParticleSystem list."<<std::endl;
             endOfRemoveRange = _psv.size();
          }
          _psv.erase(_psv.begin()+pos, _psv.begin()+endOfRemoveRange);
          return true;
       }
       return false;
    }

    inline bool ParticleSystemUpdater::replaceParticleSystem( ParticleSystem* origPS, ParticleSystem* newPS )
    {
       if( (newPS == NULL) || (origPS == newPS) ) return false;

       unsigned int pos = getParticleSystemIndex( origPS );
       if( pos < _psv.size() )
       {
          return setParticleSystem( pos, newPS );
       }
       return false;
    }

    inline bool ParticleSystemUpdater::setParticleSystem( unsigned int i, ParticleSystem* ps )
    {
       if( (i < _psv.size()) && ps )
       {
          _psv[i] = ps;
          return true;
       }
       return false;
    }

    inline unsigned int ParticleSystemUpdater::getNumParticleSystems() const
    {
        return static_cast<int>(_psv.size());
    }
    
    inline ParticleSystem* ParticleSystemUpdater::getParticleSystem(unsigned int i)
    {
        return _psv[i].get();
    }

    inline const ParticleSystem* ParticleSystemUpdater::getParticleSystem(unsigned int i) const
    {
        return _psv[i].get();
    }

    inline bool ParticleSystemUpdater::containsParticleSystem( const ParticleSystem* ps ) const
    {
       for( ParticleSystem_Vector::const_iterator itr=_psv.begin();
            itr!=_psv.end();
            ++itr )
       {
          if( itr->get() == ps ) return true;
       }
       return false;
    }

    inline unsigned int ParticleSystemUpdater::getParticleSystemIndex( const ParticleSystem* ps ) const
    {
       for( unsigned int particleSystemNum=0; particleSystemNum<_psv.size(); ++particleSystemNum )
       {
          if( _psv[particleSystemNum] == ps ) return particleSystemNum;
       }
       return _psv.size(); // node not found.
    }

}

#endif