ParticleProcessor.h

Go to the documentation of this file.

/* -*-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_PARTICLEPROCESSOR
#define OSGPARTICLE_PARTICLEPROCESSOR 1

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

#include <osg/ref_ptr>
#include <osg/Object>
#include <osg/Transform>
#include <osg/NodeVisitor>
#include <osg/CopyOp>
#include <osg/Vec3>
#include <osg/Matrix>

namespace osgParticle
{

    class OSGPARTICLE_EXPORT ParticleProcessor: public osg::Node {
    public:

        enum ReferenceFrame {
            RELATIVE_RF,
            ABSOLUTE_RF
        };

        ParticleProcessor();
        ParticleProcessor(const ParticleProcessor& copy, const osg::CopyOp& copyop = osg::CopyOp::SHALLOW_COPY);

        virtual const char* libraryName() const { return "osgParticle"; }
        virtual const char* className() const { return "ParticleProcessor"; }
        virtual bool isSameKindAs(const osg::Object* obj) const { return dynamic_cast<const ParticleProcessor*>(obj) != 0; }
        virtual void accept(osg::NodeVisitor& nv) { if (nv.validNodeMask(*this)) { nv.pushOntoNodePath(this); nv.apply(*this); nv.popFromNodePath(); } }

        inline ReferenceFrame getReferenceFrame() const;

        inline void setReferenceFrame(ReferenceFrame rf);

        bool getEnabled() const { return _enabled; }
        inline bool isEnabled() const;

        inline void setEnabled(bool v);

        inline ParticleSystem* getParticleSystem();

        inline const ParticleSystem* getParticleSystem() const;

        inline void setParticleSystem(ParticleSystem* ps);

        inline void setEndless(bool type);

        bool getEndless() const { return _endless; }
        inline bool isEndless() const;

        inline void setLifeTime(double t);

        inline double getLifeTime() const;

        inline void setStartTime(double t);

        inline double getStartTime() const;

        inline void setCurrentTime(double t);

        inline double getCurrentTime() const;

        inline void setResetTime(double t);

        inline double getResetTime() const;

        inline bool isAlive() const;

        void traverse(osg::NodeVisitor& nv);

        inline const osg::Matrix& getLocalToWorldMatrix();

        inline const osg::Matrix& getWorldToLocalMatrix();

        inline const osg::Matrix& getPreviousLocalToWorldMatrix();

        inline const osg::Matrix& getPreviousWorldToLocalMatrix();


        inline osg::Vec3 transformLocalToWorld(const osg::Vec3& P);

        inline osg::Vec3 rotateLocalToWorld(const osg::Vec3& P);

        inline osg::Vec3 transformWorldToLocal(const osg::Vec3& P);

        inline osg::Vec3 rotateWorldToLocal(const osg::Vec3& P);

        virtual osg::BoundingSphere computeBound() const;

    protected:
        virtual ~ParticleProcessor() {}
        ParticleProcessor& operator=(const ParticleProcessor&) { return *this; }

        virtual void process(double dt) = 0;

    private:
        ReferenceFrame _rf;
        bool _enabled;
        double _t0;
        osg::ref_ptr<ParticleSystem> _ps;
        bool _first_ltw_compute;
        bool _need_ltw_matrix;
        bool _first_wtl_compute;
        bool _need_wtl_matrix;
        osg::Matrix _ltw_matrix;
        osg::Matrix _wtl_matrix;
        osg::Matrix _previous_ltw_matrix;
        osg::Matrix _previous_wtl_matrix;
        osg::NodeVisitor* _current_nodevisitor;

        bool _endless;

        double _lifeTime;
        double _startTime;
        double _currentTime;
        double _resetTime;

        //added- 1/17/06- bgandere@nps.edu
        //a var to keep from doing multiple updates
        unsigned int _frameNumber;
    };

    // INLINE FUNCTIONS

    inline ParticleProcessor::ReferenceFrame ParticleProcessor::getReferenceFrame() const
    {
        return _rf;
    }

    inline void ParticleProcessor::setReferenceFrame(ReferenceFrame rf)
    {
        _rf = rf;
    }

    inline bool ParticleProcessor::isEnabled() const
    {
        return _enabled;
    }

    inline void ParticleProcessor::setEnabled(bool v)
    {
        _enabled = v;
        if (_enabled)
        {
            _currentTime = 0;
        }
    }

    inline ParticleSystem* ParticleProcessor::getParticleSystem()
    {
        return _ps.get();
    }

    inline const ParticleSystem* ParticleProcessor::getParticleSystem() const
    {
        return _ps.get();
    }

    inline void ParticleProcessor::setParticleSystem(ParticleSystem* ps)
    {
        _ps = ps;
    }

    inline void ParticleProcessor::setEndless(bool type)
    {
        _endless = type;
    }

    inline bool ParticleProcessor::isEndless() const
    {
        return _endless;
    }

    inline void ParticleProcessor::setLifeTime(double t)
    {
        _lifeTime = t;
    }

    inline double ParticleProcessor::getLifeTime() const
    {
        return _lifeTime;
    }

    inline void ParticleProcessor::setStartTime(double t)
    {
        _startTime = t;
    }

    inline double ParticleProcessor::getStartTime() const
    {
        return _startTime;
    }
    inline void ParticleProcessor::setCurrentTime(double t)
    {
        _currentTime = t;
    }

    inline double ParticleProcessor::getCurrentTime() const
    {
        return _currentTime;
    }

    inline void ParticleProcessor::setResetTime(double t)
    {
        _resetTime = t;
    }

    inline double ParticleProcessor::getResetTime() const
    {
        return _resetTime;
    }

    inline const osg::Matrix& ParticleProcessor::getLocalToWorldMatrix()
    {
        if (_need_ltw_matrix) {
            _previous_ltw_matrix = _ltw_matrix;
            _ltw_matrix = osg::computeLocalToWorld(_current_nodevisitor->getNodePath());
            if (_first_ltw_compute)
            {
                _previous_ltw_matrix = _ltw_matrix;
                _first_ltw_compute = false;
            }
            _need_ltw_matrix = false;
        }
        return _ltw_matrix;
    }

    inline const osg::Matrix& ParticleProcessor::getWorldToLocalMatrix()
    {
        if (_need_wtl_matrix) {
            _previous_wtl_matrix = _wtl_matrix;
            _wtl_matrix = osg::computeWorldToLocal(_current_nodevisitor->getNodePath());
            if (_first_wtl_compute)
            {
                _previous_wtl_matrix = _wtl_matrix;
                _first_wtl_compute = false;
            }
            _need_wtl_matrix = false;
        }
        return _wtl_matrix;
    }

    inline const osg::Matrix& ParticleProcessor::getPreviousLocalToWorldMatrix()
    {
        if (_need_ltw_matrix) getLocalToWorldMatrix();
        return _previous_ltw_matrix;
    }

    inline const osg::Matrix& ParticleProcessor::getPreviousWorldToLocalMatrix()
    {
        if (_need_wtl_matrix) getWorldToLocalMatrix();
        return _previous_wtl_matrix;
    }

    inline osg::Vec3 ParticleProcessor::transformLocalToWorld(const osg::Vec3& P)
    {
        return getLocalToWorldMatrix().preMult(P);
    }

    inline osg::Vec3 ParticleProcessor::transformWorldToLocal(const osg::Vec3& P)
    {
        return getWorldToLocalMatrix().preMult(P);
    }

    inline osg::Vec3 ParticleProcessor::rotateLocalToWorld(const osg::Vec3& P)
    {
        return getLocalToWorldMatrix().preMult(P) -
            getLocalToWorldMatrix().preMult(osg::Vec3(0, 0, 0));
    }

    inline osg::Vec3 ParticleProcessor::rotateWorldToLocal(const osg::Vec3& P)
    {
        return getWorldToLocalMatrix().preMult(P) -
            getWorldToLocalMatrix().preMult(osg::Vec3(0, 0, 0));
    }

    inline bool ParticleProcessor::isAlive() const
    {
        return _currentTime < (_lifeTime + _startTime);
    }

}


#endif