//C++ header - Open Scene Graph - Copyright (C) 1998-2002 Robert Osfield
//Distributed under the terms of the GNU Library General Public License (LGPL)
//as published by the Free Software Foundation.
//osgParticle - Copyright (C) 2002 Marco Jez

#ifndef OSGPARTICLE_MODULAREMITTER_
#define OSGPARTICLE_MODULAREMITTER_ 1

#include <osgParticle/Export>
#include <osgParticle/Emitter>
#include <osgParticle/Particle>
#include <osgParticle/RandomRateCounter>
#include <osgParticle/Placer>
#include <osgParticle/PointPlacer>
#include <osgParticle/Shooter>
#include <osgParticle/RadialShooter>
#include <osgParticle/ParticleSystem>

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

namespace osgParticle
{

    /**    An emitter class that holds three objects to control the creation of particles.
        These objects are a <I>counter</I>, a <I>placer</I> and a <I>shooter</I>.
        The counter controls the number of particles to be emitted at each frame; 
        the placer must initialize the particle's position vector, while the shooter initializes 
        its velocity vector.
        You can use the predefined counter/placer/shooter classes, or you can create your own.
    */
    class OSGPARTICLE_EXPORT ModularEmitter: public Emitter {
    public:
        ModularEmitter();
        ModularEmitter(const ModularEmitter &copy, const osg::CopyOp &copyop = osg::CopyOp::SHALLOW_COPY);
        
        META_Node(osgParticle,ModularEmitter);
        
        /// Get the counter object.
        inline Counter *getCounter();
        
        /// Get the const Counter object.
        inline const Counter *getCounter() const;
        
        /// Set the Counter object.
        inline void setCounter(Counter *c);
        
        /// Get the Placer object.
        inline Placer *getPlacer();
        
        /// Get the const Placer object.        
        inline const Placer *getPlacer() const;
        
        /// Set the Placer object.
        inline void setPlacer(Placer *p);
        
        /// Get the Shooter object.
        inline Shooter *getShooter();
        
        /// Get the const Shooter object.
        inline const Shooter *getShooter() const;
        
        /// Set the Shooter object.
        inline void setShooter(Shooter *s);        

    protected:
        virtual ~ModularEmitter() {}
        ModularEmitter &operator=(const ModularEmitter &) { return *this; }
        
        void emit(double dt);
        
    private:
        osg::ref_ptr<Counter> counter_;
        osg::ref_ptr<Placer> placer_;
        osg::ref_ptr<Shooter> shooter_;
    };
    
    // INLINE FUNCTIONS
    
    inline Counter *ModularEmitter::getCounter()
    {
        return counter_.get();
    }
    
    inline const Counter *ModularEmitter::getCounter() const
    {
        return counter_.get();
    }

    inline void ModularEmitter::setCounter(Counter *c)
    {
        counter_ = c;
    }

    inline Placer *ModularEmitter::getPlacer()
    {
        return placer_.get();
    }

    inline const Placer *ModularEmitter::getPlacer() const
    {
        return placer_.get();
    }

    inline void ModularEmitter::setPlacer(Placer *p)
    {
        placer_ = p;
    }

    inline Shooter *ModularEmitter::getShooter()
    {
        return shooter_.get();
    }

    inline const Shooter *ModularEmitter::getShooter() const
    {
        return shooter_.get();
    }

    inline void ModularEmitter::setShooter(Shooter *s)
    {
        shooter_ = s;
    }
    
}

#endif