Changeset 4121

Show
Ignore:
Timestamp:
04/29/05 11:47:57 (10 years ago)
Author:
robert
Message:

Moved osgParticle across to standard OSG coding style.

Location:
OpenSceneGraph/trunk
Files:
44 modified

Legend:

Unmodified
Added
Removed
  • OpenSceneGraph/trunk/examples/osgparticleeffects/osgparticleeffects.cpp

    r3955 r4121  
    328328                if (numGroupsFound==parents.size() && numGroupsFound==1 && insertGroup) 
    329329                { 
    330                     osg::notify(osg::NOTICE)<<"PickHandler::pick(,) hit node's parent is a single osg::Group so we can simple the insert the particle effects group here."<<std::endl; 
     330                    osg::notify(osg::INFO)<<"PickHandler::pick(,) hit node's parent is a single osg::Group so we can simple the insert the particle effects group here."<<std::endl; 
    331331 
    332332                    // just reuse the existing group. 
     
    335335                else 
    336336                {             
    337                     osg::notify(osg::NOTICE)<<"PickHandler::pick(,) hit node doesn't have an appropriate osg::Group node to insert particle effects into, inserting a new osg::Group."<<std::endl; 
     337                    osg::notify(osg::INFO)<<"PickHandler::pick(,) hit node doesn't have an appropriate osg::Group node to insert particle effects into, inserting a new osg::Group."<<std::endl; 
    338338                    insertGroup = new osg::Group; 
    339339                    for(osg::Node::ParentList::iterator itr=parents.begin(); 
     
    361361            { 
    362362                // when we don't have moving models we can simple insert the particle effect into the root of the scene graph 
    363                 osg::notify(osg::NOTICE)<<"PickHandler::pick(,) adding particle effects to root node."<<std::endl; 
     363                osg::notify(osg::INFO)<<"PickHandler::pick(,) adding particle effects to root node."<<std::endl; 
    364364                root->addChild(effectsGroup); 
    365365            } 
  • OpenSceneGraph/trunk/include/osgParticle/AccelOperator

    r4038 r4121  
    1313//osgParticle - Copyright (C) 2002 Marco Jez 
    1414 
    15 #ifndef OSGPARTICLE_ACCELOPERATOR_ 
    16 #define OSGPARTICLE_ACCELOPERATOR_ 1 
     15#ifndef OSGPARTICLE_ACCELOPERATOR 
     16#define OSGPARTICLE_ACCELOPERATOR 1 
    1717 
    1818#include <osgParticle/ModularProgram> 
     
    3232    public: 
    3333        inline AccelOperator(); 
    34         inline AccelOperator(const AccelOperator &copy, const osg::CopyOp &copyop = osg::CopyOp::SHALLOW_COPY); 
     34        inline AccelOperator(const AccelOperator& copy, const osg::CopyOp& copyop = osg::CopyOp::SHALLOW_COPY); 
    3535 
    3636        META_Object(osgParticle, AccelOperator); 
    3737 
    3838        /// Get the acceleration vector. 
    39         inline const osg::Vec3 &getAcceleration() const; 
     39        inline const osg::Vec3& getAcceleration() const; 
    4040         
    4141        /// Set the acceleration vector. 
    42         inline void setAcceleration(const osg::Vec3 &v); 
     42        inline void setAcceleration(const osg::Vec3& v); 
    4343         
    4444        /** Quickly set the acceleration vector to the gravity on earth (0, 0, -9.81). 
     
    4848         
    4949        /// Apply the acceleration to a particle. Do not call this method manually. 
    50         inline void operate(Particle *P, double dt); 
     50        inline void operate(Particle* P, double dt); 
    5151         
    5252        /// Perform some initializations. Do not call this method manually. 
     
    5858 
    5959    private: 
    60         osg::Vec3 accel_; 
    61         osg::Vec3 xf_accel_; 
     60        osg::Vec3 _accel; 
     61        osg::Vec3 _xf_accel; 
    6262    }; 
    6363 
     
    6565     
    6666    inline AccelOperator::AccelOperator() 
    67     : Operator(), accel_(0, 0, 0) 
     67    : Operator(), _accel(0, 0, 0) 
    6868    { 
    6969    } 
    7070     
    71     inline AccelOperator::AccelOperator(const AccelOperator &copy, const osg::CopyOp &copyop) 
    72     : Operator(copy, copyop), accel_(copy.accel_) 
     71    inline AccelOperator::AccelOperator(const AccelOperator& copy, const osg::CopyOp& copyop) 
     72    : Operator(copy, copyop), _accel(copy._accel) 
    7373    { 
    7474    } 
    7575 
    76     inline const osg::Vec3 &AccelOperator::getAcceleration() const 
     76    inline const osg::Vec3& AccelOperator::getAcceleration() const 
    7777    { 
    78         return accel_; 
     78        return _accel; 
    7979    } 
    8080 
    81     inline void AccelOperator::setAcceleration(const osg::Vec3 &v) 
     81    inline void AccelOperator::setAcceleration(const osg::Vec3& v) 
    8282    { 
    83         accel_ = v; 
     83        _accel = v; 
    8484    } 
    8585     
    8686    inline void AccelOperator::setToGravity(float scale) 
    8787    { 
    88         accel_.set(0, 0, -9.80665f * scale); 
     88        _accel.set(0, 0, -9.80665f * scale); 
    8989    } 
    9090 
    91     inline void AccelOperator::operate(Particle *P, double dt) 
     91    inline void AccelOperator::operate(Particle* P, double dt) 
    9292    { 
    93         P->addVelocity(xf_accel_ * dt); 
     93        P->addVelocity(_xf_accel * dt); 
    9494    } 
    9595     
     
    9797    { 
    9898        if (prg->getReferenceFrame() == ModularProgram::RELATIVE_RF) { 
    99             xf_accel_ = prg->rotateLocalToWorld(accel_); 
     99            _xf_accel = prg->rotateLocalToWorld(_accel); 
    100100        } else { 
    101             xf_accel_ = accel_; 
     101            _xf_accel = _accel; 
    102102        } 
    103103    } 
  • OpenSceneGraph/trunk/include/osgParticle/AngularAccelOperator

    r4038 r4121  
    1313//osgParticle - Copyright (C) 2002 Marco Jez 
    1414 
    15 #ifndef OSGPARTICLE_ANGULARACCELOPERATOR_ 
    16 #define OSGPARTICLE_ANGULARACCELOPERATOR_ 1 
     15#ifndef OSGPARTICLE_ANGULARACCELOPERATOR 
     16#define OSGPARTICLE_ANGULARACCELOPERATOR 1 
    1717 
    1818#include <osgParticle/ModularProgram> 
     
    3333    public: 
    3434        inline AngularAccelOperator(); 
    35         inline AngularAccelOperator(const AngularAccelOperator &copy, const osg::CopyOp &copyop = osg::CopyOp::SHALLOW_COPY); 
     35        inline AngularAccelOperator(const AngularAccelOperator& copy, const osg::CopyOp& copyop = osg::CopyOp::SHALLOW_COPY); 
    3636 
    3737        META_Object(osgParticle, AngularAccelOperator); 
    3838 
    3939        /// Get the angular acceleration vector. 
    40         inline const osg::Vec3 &getAngularAcceleration() const; 
     40        inline const osg::Vec3& getAngularAcceleration() const; 
    4141         
    4242        /// Set the angular acceleration vector. 
    43         inline void setAngularAcceleration(const osg::Vec3 &v); 
     43        inline void setAngularAcceleration(const osg::Vec3& v); 
    4444         
    4545        /// Apply the angular acceleration to a particle. Do not call this method manually. 
    46         inline void operate(Particle *P, double dt); 
     46        inline void operate(Particle* P, double dt); 
    4747         
    4848        /// Perform some initializations. Do not call this method manually. 
     
    5151    protected: 
    5252        virtual ~AngularAccelOperator() {} 
    53         AngularAccelOperator &operator=(const AngularAccelOperator &) { return *this; }         
     53        AngularAccelOperator& operator=(const AngularAccelOperator& ) { return *this; }         
    5454 
    5555    private: 
    56         osg::Vec3 angular_accel_; 
    57         osg::Vec3 xf_angular_accel_; 
     56        osg::Vec3 _angul_araccel; 
     57        osg::Vec3 _xf_angul_araccel; 
    5858    }; 
    5959 
     
    6161     
    6262    inline AngularAccelOperator::AngularAccelOperator() 
    63     : Operator(), angular_accel_(0, 0, 0) 
     63    : Operator(), _angul_araccel(0, 0, 0) 
    6464    { 
    6565    } 
    6666     
    67     inline AngularAccelOperator::AngularAccelOperator(const AngularAccelOperator &copy, const osg::CopyOp &copyop) 
    68     : Operator(copy, copyop), angular_accel_(copy.angular_accel_) 
     67    inline AngularAccelOperator::AngularAccelOperator(const AngularAccelOperator& copy, const osg::CopyOp& copyop) 
     68    : Operator(copy, copyop), _angul_araccel(copy._angul_araccel) 
    6969    { 
    7070    } 
    7171 
    72     inline const osg::Vec3 &AngularAccelOperator::getAngularAcceleration() const 
     72    inline const osg::Vec3& AngularAccelOperator::getAngularAcceleration() const 
    7373    { 
    74         return angular_accel_; 
     74        return _angul_araccel; 
    7575    } 
    7676 
    77     inline void AngularAccelOperator::setAngularAcceleration(const osg::Vec3 &v) 
     77    inline void AngularAccelOperator::setAngularAcceleration(const osg::Vec3& v) 
    7878    { 
    79         angular_accel_ = v; 
     79        _angul_araccel = v; 
    8080    } 
    8181 
    82     inline void AngularAccelOperator::operate(Particle *P, double dt) 
     82    inline void AngularAccelOperator::operate(Particle* P, double dt) 
    8383    { 
    84         P->addAngularVelocity(xf_angular_accel_ * dt); 
     84        P->addAngularVelocity(_xf_angul_araccel * dt); 
    8585    } 
    8686     
     
    8888    { 
    8989        if (prg->getReferenceFrame() == ModularProgram::RELATIVE_RF) { 
    90             xf_angular_accel_ = prg->rotateLocalToWorld(angular_accel_); 
     90            _xf_angul_araccel = prg->rotateLocalToWorld(_angul_araccel); 
    9191        } else { 
    92             xf_angular_accel_ = angular_accel_; 
     92            _xf_angul_araccel = _angul_araccel; 
    9393        } 
    9494    } 
  • OpenSceneGraph/trunk/include/osgParticle/CenteredPlacer

    r4038 r4121  
    1313//osgParticle - Copyright (C) 2002 Marco Jez 
    1414 
    15 #ifndef OSGPARTICLE_CENTEREDPLACER_ 
    16 #define OSGPARTICLE_CENTEREDPLACER_ 1 
     15#ifndef OSGPARTICLE_CENTERED_PLACER 
     16#define OSGPARTICLE_CENTERED_PLACER 1 
    1717 
    1818#include <osgParticle/Placer> 
     
    3030    public: 
    3131        inline CenteredPlacer(); 
    32         inline CenteredPlacer(const CenteredPlacer &copy, const osg::CopyOp &copyop = osg::CopyOp::SHALLOW_COPY); 
     32        inline CenteredPlacer(const CenteredPlacer& copy, const osg::CopyOp& copyop = osg::CopyOp::SHALLOW_COPY); 
    3333         
    34         virtual const char *libraryName() const { return "osgParticle"; } 
    35         virtual const char *className() const { return "CenteredPlacer"; } 
    36         virtual bool isSameKindAs(const osg::Object *obj) const { return dynamic_cast<const Placer *>(obj) != 0; }         
     34        virtual const char* libraryName() const { return "osgParticle"; } 
     35        virtual const char* className() const { return "CenteredPlacer"; } 
     36        virtual bool isSameKindAs(const osg::Object* obj) const { return dynamic_cast<const Placer* >(obj) != 0; }         
    3737     
    3838        /// Get the center point. 
    39         inline const osg::Vec3 &getCenter() const; 
     39        inline const osg::Vec3& getCenter() const; 
    4040         
    4141        /// Set the center point. 
    42         inline void setCenter(const osg::Vec3 &v); 
     42        inline void setCenter(const osg::Vec3& v); 
    4343         
    4444        /// Set the center point. 
     
    5959    } 
    6060     
    61     inline CenteredPlacer::CenteredPlacer(const CenteredPlacer &copy, const osg::CopyOp &copyop) 
     61    inline CenteredPlacer::CenteredPlacer(const CenteredPlacer& copy, const osg::CopyOp& copyop) 
    6262    : Placer(copy, copyop), center_(copy.center_) 
    6363    { 
    6464    } 
    6565     
    66     inline const osg::Vec3 &CenteredPlacer::getCenter() const 
     66    inline const osg::Vec3& CenteredPlacer::getCenter() const 
    6767    { 
    6868        return center_; 
    6969    } 
    7070     
    71     inline void CenteredPlacer::setCenter(const osg::Vec3 &v) 
     71    inline void CenteredPlacer::setCenter(const osg::Vec3& v) 
    7272    { 
    7373        center_ = v; 
  • OpenSceneGraph/trunk/include/osgParticle/Counter

    r4038 r4121  
    1313//osgParticle - Copyright (C) 2002 Marco Jez 
    1414 
    15 #ifndef OSGPARTICLE_COUNTER_ 
    16 #define OSGPARTICLE_COUNTER_ 1 
     15#ifndef OSGPARTICLE_COUNTER 
     16#define OSGPARTICLE_COUNTER 1 
    1717 
    1818#include <osg/CopyOp> 
     
    2525    public: 
    2626        inline Counter(); 
    27         inline Counter(const Counter &copy, const osg::CopyOp &copyop = osg::CopyOp::SHALLOW_COPY); 
     27        inline Counter(const Counter& copy, const osg::CopyOp& copyop = osg::CopyOp::SHALLOW_COPY); 
    2828 
    29         virtual const char *libraryName() const { return "osgParticle"; } 
    30         virtual const char *className() const { return "Counter"; } 
    31         virtual bool isSameKindAs(const osg::Object *obj) const { return dynamic_cast<const Counter *>(obj) != 0; } 
     29        virtual const char* libraryName() const { return "osgParticle"; } 
     30        virtual const char* className() const { return "Counter"; } 
     31        virtual bool isSameKindAs(const osg::Object* obj) const { return dynamic_cast<const Counter* >(obj) != 0; } 
    3232 
    3333        virtual int numParticlesToCreate(double dt) const = 0; 
     
    4545    } 
    4646     
    47     inline Counter::Counter(const Counter &copy, const osg::CopyOp &copyop) 
     47    inline Counter::Counter(const Counter& copy, const osg::CopyOp& copyop) 
    4848    : osg::Object(copy, copyop) 
    4949    { 
  • OpenSceneGraph/trunk/include/osgParticle/Emitter

    r4106 r4121  
    1313//osgParticle - Copyright (C) 2002 Marco Jez 
    1414 
    15 #ifndef OSGPARTICLE_EMITTER_ 
    16 #define OSGPARTICLE_EMITTER_ 1 
     15#ifndef OSGPARTICLE_EMITTER 
     16#define OSGPARTICLE_EMITTER 1 
    1717 
    1818#include <osgParticle/Export> 
     
    3636    public: 
    3737        Emitter(); 
    38         Emitter(const Emitter &copy, const osg::CopyOp &copyop = osg::CopyOp::SHALLOW_COPY); 
     38        Emitter(const Emitter& copy, const osg::CopyOp& copyop = osg::CopyOp::SHALLOW_COPY); 
    3939 
    40         virtual const char *libraryName() const { return "osgParticle"; } 
    41         virtual const char *className() const { return "Emitter"; } 
    42         virtual bool isSameKindAs(const osg::Object *obj) const { return dynamic_cast<const Emitter*>(obj) != 0; } 
     40        virtual const char* libraryName() const { return "osgParticle"; } 
     41        virtual const char* className() const { return "Emitter"; } 
     42        virtual bool isSameKindAs(const osg::Object* obj) const { return dynamic_cast<const Emitter*>(obj) != 0; } 
    4343        virtual void accept(osg::NodeVisitor& nv) { if (nv.validNodeMask(*this)) { nv.pushOntoNodePath(this); nv.apply(*this); nv.popFromNodePath(); } } 
    4444         
    4545        /// Get the particle template. 
    46         inline const Particle &getParticleTemplate() const; 
     46        inline const Particle& getParticleTemplate() const; 
    4747         
    4848        /// Set the particle template (particle is copied). 
    49         inline void setParticleTemplate(const Particle &p); 
     49        inline void setParticleTemplate(const Particle& p); 
    5050         
    5151        /// Return whether the particle system's default template should be used. 
     
    6060    protected: 
    6161        virtual ~Emitter() {} 
    62         Emitter &operator=(const Emitter &) { return *this; } 
     62        Emitter& operator=(const Emitter&) { return *this; } 
    6363         
    6464        inline void process(double dt); 
     
    6666        virtual void emit(double dt) = 0; 
    6767         
    68         bool usedeftemp_; 
    69         Particle ptemp_; 
     68        bool _usedeftemp; 
     69        Particle _ptemp; 
    7070    }; 
    7171 
    7272    // INLINE FUNCTIONS 
    7373 
    74     inline const Particle &Emitter::getParticleTemplate() const 
     74    inline const Particle& Emitter::getParticleTemplate() const 
    7575    { 
    76         return ptemp_; 
     76        return _ptemp; 
    7777    } 
    7878 
    79     inline void Emitter::setParticleTemplate(const Particle &p) 
     79    inline void Emitter::setParticleTemplate(const Particle& p) 
    8080    { 
    81         ptemp_ = p; 
    82         usedeftemp_ = false; 
     81        _ptemp = p; 
     82        _usedeftemp = false; 
    8383    } 
    8484 
    8585    inline bool Emitter::getUseDefaultTemplate() const 
    8686    { 
    87         return usedeftemp_; 
     87        return _usedeftemp; 
    8888    } 
    8989 
    9090    inline void Emitter::setUseDefaultTemplate(bool v) 
    9191    { 
    92         usedeftemp_ = v; 
     92        _usedeftemp = v; 
    9393    } 
    9494 
  • OpenSceneGraph/trunk/include/osgParticle/FireEffect

    r4038 r4121  
    1212*/ 
    1313 
    14 #ifndef OSGPARTICLE_FireEffect 
    15 #define OSGPARTICLE_FireEffect 
     14#ifndef OSGPARTICLE_FIREEFFECT 
     15#define OSGPARTICLE_FIREEFFECT 
    1616 
    1717#include <osgParticle/ParticleEffect> 
  • OpenSceneGraph/trunk/include/osgParticle/FluidFrictionOperator

    r4038 r4121  
    1313//osgParticle - Copyright (C) 2002 Marco Jez 
    1414 
    15 #ifndef OSGPARTICLE_FLUIDFRICTIONOPERATOR_ 
    16 #define OSGPARTICLE_FLUIDFRICTIONOPERATOR_ 1 
     15#ifndef OSGPARTICLE_FLUIDFRICTIONOPERATOR 
     16#define OSGPARTICLE_FLUIDFRICTIONOPERATOR 1 
    1717 
    1818#include <osgParticle/Export> 
     
    3838         
    3939        FluidFrictionOperator(); 
    40         FluidFrictionOperator(const FluidFrictionOperator &copy, const osg::CopyOp &copyop = osg::CopyOp::SHALLOW_COPY); 
     40        FluidFrictionOperator(const FluidFrictionOperator& copy, const osg::CopyOp& copyop = osg::CopyOp::SHALLOW_COPY); 
    4141         
    4242        META_Object(osgParticle, FluidFrictionOperator); 
     
    7373         
    7474        /// Apply the friction forces to a particle. Do not call this method manually. 
    75         void operate(Particle *P, double dt); 
     75        void operate(Particle* P, double dt); 
    7676         
    7777        /// Perform some initializations. Do not call this method manually. 
    78         inline void beginOperate(Program *prg); 
     78        inline void beginOperate(Program* prg); 
    7979         
    8080    protected: 
     
    8383         
    8484    private: 
    85         float       A_; 
    86         float       B_; 
    87         float       density_; 
    88         float       viscosity_; 
    89         float       ovr_rad_; 
     85        float       _coeff_A; 
     86        float       _coeff_B; 
     87        float       _density; 
     88        float       _viscosity; 
     89        float       _ovr_rad; 
    9090        osg::Vec3   _wind; 
    91         Program *current_program_; 
     91        Program*    _current_program; 
    9292    }; 
    9393     
     
    9696    inline float FluidFrictionOperator::getFluidDensity() const 
    9797    { 
    98         return density_; 
     98        return _density; 
    9999    } 
    100100 
    101101    inline float FluidFrictionOperator::getFluidViscosity() const 
    102102    { 
    103         return viscosity_; 
     103        return _viscosity; 
    104104    } 
    105105     
    106106    inline void FluidFrictionOperator::setFluidDensity(float d) 
    107107    { 
    108         density_ = d; 
    109         B_ = 0.2f * osg::PI * density_; 
     108        _density = d; 
     109        _coeff_B = 0.2f * osg::PI * _density; 
    110110    } 
    111111 
    112112    inline void FluidFrictionOperator::setFluidViscosity(float v) 
    113113    { 
    114         viscosity_ = v; 
    115         A_ = 6 * osg::PI * viscosity_; 
     114        _viscosity = v; 
     115        _coeff_A = 6 * osg::PI * _viscosity; 
    116116    } 
    117117     
     
    130130    inline float FluidFrictionOperator::getOverrideRadius() const 
    131131    { 
    132         return ovr_rad_; 
     132        return _ovr_rad; 
    133133    } 
    134134     
    135135    inline void FluidFrictionOperator::setOverrideRadius(float r) 
    136136    { 
    137         ovr_rad_ = r; 
     137        _ovr_rad = r; 
    138138    } 
    139139     
    140     inline void FluidFrictionOperator::beginOperate(Program *prg) 
     140    inline void FluidFrictionOperator::beginOperate(Program* prg) 
    141141    { 
    142         current_program_ = prg; 
     142        _current_program = prg; 
    143143    } 
    144144 
  • OpenSceneGraph/trunk/include/osgParticle/FluidProgram

    r4038 r4121  
    1212*/ 
    1313 
    14 #ifndef OSGPARTICLE_FLUIDPROGRAM_ 
    15 #define OSGPARTICLE_FLUIDPROGRAM_ 1 
     14#ifndef OSGPARTICLE_FLUIDPROGRAM 
     15#define OSGPARTICLE_FLUIDPROGRAM 1 
    1616 
    1717#include <osgParticle/Export> 
  • OpenSceneGraph/trunk/include/osgParticle/ForceOperator

    r4038 r4121  
    1313//osgParticle - Copyright (C) 2002 Marco Jez 
    1414 
    15 #ifndef OSGPARTICLE_FORCEOPERATOR_ 
    16 #define OSGPARTICLE_FORCEOPERATOR_ 1 
     15#ifndef OSGPARTICLE_FORCEOPERATOR 
     16#define OSGPARTICLE_FORCEOPERATOR 1 
    1717 
    1818#include <osgParticle/ModularProgram> 
     
    3434    public: 
    3535        inline ForceOperator(); 
    36         inline ForceOperator(const ForceOperator &copy, const osg::CopyOp &copyop = osg::CopyOp::SHALLOW_COPY); 
     36        inline ForceOperator(const ForceOperator& copy, const osg::CopyOp& copyop = osg::CopyOp::SHALLOW_COPY); 
    3737         
    3838        META_Object(osgParticle, ForceOperator); 
    3939         
    4040        /// Get the force vector. 
    41         inline const osg::Vec3 &getForce() const; 
     41        inline const osg::Vec3& getForce() const; 
    4242         
    4343        /// Set the force vector. 
    44         inline void setForce(const osg::Vec3 &f); 
     44        inline void setForce(const osg::Vec3& f); 
    4545         
    4646        /// Apply the force to a particle. Do not call this method manually. 
    47         inline void operate(Particle *P, double dt); 
     47        inline void operate(Particle* P, double dt); 
    4848         
    4949        /// Perform some initialization. Do not call this method manually. 
     
    5252    protected: 
    5353        virtual ~ForceOperator() {}; 
    54         ForceOperator &operator=(const ForceOperator &) { return *this; }         
     54        ForceOperator& operator=(const ForceOperator&) { return *this; }         
    5555         
    5656    private: 
    57         osg::Vec3 force_; 
    58         osg::Vec3 xf_force_; 
     57        osg::Vec3 _force; 
     58        osg::Vec3 _xf_force; 
    5959    }; 
    6060     
     
    6262     
    6363    inline ForceOperator::ForceOperator() 
    64     : Operator(), force_(0, 0, 0) 
     64    : Operator(), _force(0, 0, 0) 
    6565    {         
    6666    } 
    6767     
    68     inline ForceOperator::ForceOperator(const ForceOperator &copy, const osg::CopyOp &copyop) 
    69     : Operator(copy, copyop), force_(copy.force_) 
     68    inline ForceOperator::ForceOperator(const ForceOperator& copy, const osg::CopyOp& copyop) 
     69    : Operator(copy, copyop), _force(copy._force) 
    7070    { 
    7171    } 
    7272     
    73     inline const osg::Vec3 &ForceOperator::getForce() const 
     73    inline const osg::Vec3& ForceOperator::getForce() const 
    7474    { 
    75         return force_; 
     75        return _force; 
    7676    } 
    7777     
    78     inline void ForceOperator::setForce(const osg::Vec3 &v) 
     78    inline void ForceOperator::setForce(const osg::Vec3& v) 
    7979    { 
    80         force_ = v; 
     80        _force = v; 
    8181    } 
    8282     
    83     inline void ForceOperator::operate(Particle *P, double dt) 
     83    inline void ForceOperator::operate(Particle* P, double dt) 
    8484    { 
    85         P->addVelocity(xf_force_ * (P->getMassInv() * dt)); 
     85        P->addVelocity(_xf_force * (P->getMassInv() * dt)); 
    8686    } 
    8787     
     
    8989    { 
    9090        if (prg->getReferenceFrame() == ModularProgram::RELATIVE_RF) { 
    91             xf_force_ = prg->rotateLocalToWorld(force_); 
     91            _xf_force = prg->rotateLocalToWorld(_force); 
    9292        } else { 
    93             xf_force_ = force_; 
     93            _xf_force = _force; 
    9494        } 
    9595    } 
  • OpenSceneGraph/trunk/include/osgParticle/Interpolator

    r4038 r4121  
    1313//osgParticle - Copyright (C) 2002 Marco Jez 
    1414 
    15 #ifndef OSGPARTICLE_INTERPOLATOR_ 
    16 #define OSGPARTICLE_INTERPOLATOR_ 
     15#ifndef OSGPARTICLE_INTERPOLATOR 
     16#define OSGPARTICLE_INTERPOLATOR 
    1717 
    1818#include <osgParticle/range> 
     
    3333        : osg::Object() {} 
    3434         
    35         Interpolator(const Interpolator &copy, const osg::CopyOp &copyop = osg::CopyOp::SHALLOW_COPY) 
     35        Interpolator(const Interpolator& copy, const osg::CopyOp& copyop = osg::CopyOp::SHALLOW_COPY) 
    3636        : osg::Object(copy, copyop) {} 
    3737         
    38         virtual const char *libraryName() const { return "osgParticle"; } 
    39         virtual const char *className() const { return "Interpolator"; } 
    40         virtual bool isSameKindAs(const osg::Object *obj) const { return dynamic_cast<const Interpolator *>(obj) != 0; } 
     38        virtual const char* libraryName() const { return "osgParticle"; } 
     39        virtual const char* className() const { return "Interpolator"; } 
     40        virtual bool isSameKindAs(const osg::Object* obj) const { return dynamic_cast<const Interpolator* >(obj) != 0; } 
    4141                 
    4242        /// Interpolate between floats. Must be overriden in descendant classes. 
     
    4444         
    4545        /// Interpolate between 2-dimensional vectors. Default behavior is to interpolate each component separately. 
    46         virtual osg::Vec2 interpolate(float t, const osg::Vec2 &y1, const osg::Vec2 &y2) const 
     46        virtual osg::Vec2 interpolate(float t, const osg::Vec2& y1, const osg::Vec2& y2) const 
    4747        { 
    4848            return osg::Vec2( 
     
    5353 
    5454        /// Interpolate between 3-dimensional vectors. Default behavior is to interpolate each component separately. 
    55         virtual osg::Vec3 interpolate(float t, const osg::Vec3 &y1, const osg::Vec3 &y2) const 
     55        virtual osg::Vec3 interpolate(float t, const osg::Vec3& y1, const osg::Vec3& y2) const 
    5656        { 
    5757            return osg::Vec3( 
     
    6363         
    6464        /// Interpolate between 4-dimensional vectors. Default behavior is to interpolate each component separately. 
    65         virtual osg::Vec4 interpolate(float t, const osg::Vec4 &y1, const osg::Vec4 &y2) const 
     65        virtual osg::Vec4 interpolate(float t, const osg::Vec4& y1, const osg::Vec4& y2) const 
    6666        { 
    6767            return osg::Vec4( 
     
    7373        } 
    7474         
    75         template<class T_> 
    76         T_ interpolate(float t, const range<T_> &r) const 
     75        template<class ValueType> 
     76        ValueType interpolate(float t, const range<ValueType>& r) const 
    7777        { 
    7878            return interpolate(t, r.minimum, r.maximum); 
  • OpenSceneGraph/trunk/include/osgParticle/LinearInterpolator

    r4038 r4121  
    1313//osgParticle - Copyright (C) 2002 Marco Jez 
    1414 
    15 #ifndef OSGPARTICLE_LINEARINTERPOLATOR_ 
    16 #define OSGPARTICLE_LINEARINTERPOLATOR_ 
     15#ifndef OSGPARTICLE_LINEARINTERPOLATOR 
     16#define OSGPARTICLE_LINEARINTERPOLATOR 
    1717 
    1818#include <osgParticle/Interpolator> 
     
    2727 
    2828    /// A linear interpolator. 
    29     class LinearInterpolator: public Interpolator { 
     29    class LinearInterpolator: public Interpolator 
     30    { 
    3031    public: 
    3132        LinearInterpolator() 
    3233        : Interpolator() {} 
    3334         
    34         LinearInterpolator(const LinearInterpolator &copy, const osg::CopyOp &copyop = osg::CopyOp::SHALLOW_COPY) 
     35        LinearInterpolator(const LinearInterpolator& copy, const osg::CopyOp& copyop = osg::CopyOp::SHALLOW_COPY) 
    3536        : Interpolator(copy, copyop) {} 
    3637         
  • OpenSceneGraph/trunk/include/osgParticle/ModularEmitter

    r4106 r4121  
    1313//osgParticle - Copyright (C) 2002 Marco Jez 
    1414 
    15 #ifndef OSGPARTICLE_MODULAREMITTER_ 
    16 #define OSGPARTICLE_MODULAREMITTER_ 1 
     15#ifndef OSGPARTICLE_MODULAREMITTER 
     16#define OSGPARTICLE_MODULAREMITTER 1 
    1717 
    1818#include <osgParticle/Export> 
     
    4545    public: 
    4646        ModularEmitter(); 
    47         ModularEmitter(const ModularEmitter &copy, const osg::CopyOp &copyop = osg::CopyOp::SHALLOW_COPY); 
     47        ModularEmitter(const ModularEmitter& copy, const osg::CopyOp& copyop = osg::CopyOp::SHALLOW_COPY); 
    4848         
    4949        META_Node(osgParticle,ModularEmitter); 
    5050         
    5151        /// Get the counter object. 
    52         inline Counter *getCounter(); 
     52        inline Counter* getCounter(); 
    5353         
    5454        /// Get the const Counter object. 
    55         inline const Counter *getCounter() const; 
     55        inline const Counter* getCounter() const; 
    5656         
    5757        /// Set the Counter object. 
    58         inline void setCounter(Counter *c); 
     58        inline void setCounter(Counter* c); 
    5959         
    6060        /// Get the Placer object. 
    61         inline Placer *getPlacer(); 
     61        inline Placer* getPlacer(); 
    6262         
    6363        /// Get the const Placer object.         
    64         inline const Placer *getPlacer() const; 
     64        inline const Placer* getPlacer() const; 
    6565         
    6666        /// Set the Placer object. 
    67         inline void setPlacer(Placer *p); 
     67        inline void setPlacer(Placer* p); 
    6868         
    6969        /// Get the Shooter object. 
     
    8383         
    8484    private: 
    85         osg::ref_ptr<Counter> counter_; 
    86         osg::ref_ptr<Placer> placer_; 
    87         osg::ref_ptr<Shooter> shooter_; 
     85        osg::ref_ptr<Counter> _counter; 
     86        osg::ref_ptr<Placer> _placer; 
     87        osg::ref_ptr<Shooter> _shooter; 
    8888    }; 
    8989     
    9090    // INLINE FUNCTIONS 
    9191     
    92     inline Counter *ModularEmitter::getCounter() 
     92    inline Counter* ModularEmitter::getCounter() 
    9393    { 
    94         return counter_.get(); 
     94        return _counter.get(); 
    9595    } 
    9696     
    97     inline const Counter *ModularEmitter::getCounter() const 
     97    inline const Counter* ModularEmitter::getCounter() const 
    9898    { 
    99         return counter_.get(); 
     99        return _counter.get(); 
    100100    } 
    101101 
    102     inline void ModularEmitter::setCounter(Counter *c) 
     102    inline void ModularEmitter::setCounter(Counter* c) 
    103103    { 
    104         counter_ = c; 
     104        _counter = c; 
    105105    } 
    106106 
    107     inline Placer *ModularEmitter::getPlacer() 
     107    inline Placer* ModularEmitter::getPlacer() 
    108108    { 
    109         return placer_.get(); 
     109        return _placer.get(); 
    110110    } 
    111111 
    112     inline const Placer *ModularEmitter::getPlacer() const 
     112    inline const Placer* ModularEmitter::getPlacer() const 
    113113    { 
    114         return placer_.get(); 
     114        return _placer.get(); 
    115115    } 
    116116 
    117     inline void ModularEmitter::setPlacer(Placer *p) 
     117    inline void ModularEmitter::setPlacer(Placer* p) 
    118118    { 
    119         placer_ = p; 
     119        _placer = p; 
    120120    } 
    121121 
    122122    inline Shooter *ModularEmitter::getShooter() 
    123123    { 
    124         return shooter_.get(); 
     124        return _shooter.get(); 
    125125    } 
    126126 
    127127    inline const Shooter *ModularEmitter::getShooter() const 
    128128    { 
    129         return shooter_.get(); 
     129        return _shooter.get(); 
    130130    } 
    131131 
    132132    inline void ModularEmitter::setShooter(Shooter *s) 
    133133    { 
    134         shooter_ = s; 
     134        _shooter = s; 
    135135    } 
    136136     
  • OpenSceneGraph/trunk/include/osgParticle/ModularProgram

    r4038 r4121  
    1313//osgParticle - Copyright (C) 2002 Marco Jez 
    1414 
    15 #ifndef OSGPARTICLE_MODULARPROGRAM_ 
    16 #define OSGPARTICLE_MODULARPROGRAM_ 1 
     15#ifndef OSGPARTICLE_MODULARPROGRAM 
     16#define OSGPARTICLE_MODULARPROGRAM 1 
    1717 
    1818#include <osgParticle/Export> 
     
    3636    public: 
    3737        ModularProgram(); 
    38         ModularProgram(const ModularProgram &copy, const osg::CopyOp &copyop = osg::CopyOp::SHALLOW_COPY); 
     38        ModularProgram(const ModularProgram& copy, const osg::CopyOp& copyop = osg::CopyOp::SHALLOW_COPY); 
    3939         
    4040        META_Node(osgParticle,ModularProgram); 
     
    4444         
    4545        /// Add an operator to the list.         
    46         inline void addOperator(Operator *o); 
     46        inline void addOperator(Operator* o); 
    4747         
    4848        /// Get a pointer to an operator in the list. 
    49         inline Operator *getOperator(int i); 
     49        inline Operator* getOperator(int i); 
    5050         
    5151        /// Get a const pointer to an operator in the list. 
    52         inline const Operator *getOperator(int i) const; 
     52        inline const Operator* getOperator(int i) const; 
    5353         
    5454        /// Remove an operator from the list. 
     
    5757    protected: 
    5858        virtual ~ModularProgram() {} 
    59         ModularProgram &operator=(const ModularProgram &) { return *this; } 
     59        ModularProgram& operator=(const ModularProgram&) { return *this; } 
    6060         
    6161        void execute(double dt); 
     
    6464        typedef std::vector<osg::ref_ptr<Operator> > Operator_vector; 
    6565 
    66         Operator_vector operators_; 
     66        Operator_vector _operators; 
    6767    }; 
    6868     
     
    7171    inline int ModularProgram::numOperators() const 
    7272    { 
    73         return static_cast<int>(operators_.size()); 
     73        return static_cast<int>(_operators.size()); 
    7474    } 
    7575 
    76     inline void ModularProgram::addOperator(Operator *o) 
     76    inline void ModularProgram::addOperator(Operator* o) 
    7777    { 
    78         operators_.push_back(o); 
     78        _operators.push_back(o); 
    7979    } 
    8080 
    81     inline Operator *ModularProgram::getOperator(int i) 
     81    inline Operator* ModularProgram::getOperator(int i) 
    8282    { 
    83         return operators_[i].get(); 
     83        return _operators[i].get(); 
    8484    } 
    8585 
    86     inline const Operator *ModularProgram::getOperator(int i) const 
     86    inline const Operator* ModularProgram::getOperator(int i) const 
    8787    { 
    88         return operators_[i].get(); 
     88        return _operators[i].get(); 
    8989    } 
    9090 
    9191    inline void ModularProgram::removeOperator(int i) 
    9292    { 
    93         operators_.erase(operators_.begin()+i); 
     93        _operators.erase(_operators.begin()+i); 
    9494    } 
    9595     
  • OpenSceneGraph/trunk/include/osgParticle/MultiSegmentPlacer

    r4038 r4121  
    1313//osgParticle - Copyright (C) 2002 Marco Jez 
    1414 
    15 #ifndef OSGPARTICLE_MULTISEGMENTPLACER_ 
    16 #define OSGPARTICLE_MULTISEGMENTPLACER_ 1 
     15#ifndef OSGPARTICLE_MULTISEGMENT_PLACER 
     16#define OSGPARTICLE_MULTISEGMENT_PLACER 1 
    1717 
    1818#include <osgParticle/Export> 
     
    3737    public: 
    3838        MultiSegmentPlacer(); 
    39         MultiSegmentPlacer(const MultiSegmentPlacer &copy, const osg::CopyOp &copyop = osg::CopyOp::SHALLOW_COPY); 
     39        MultiSegmentPlacer(const MultiSegmentPlacer& copy, const osg::CopyOp& copyop = osg::CopyOp::SHALLOW_COPY); 
    4040 
    4141        META_Object(osgParticle, MultiSegmentPlacer); 
     
    4545         
    4646        /// Get a vertex. 
    47         inline const osg::Vec3 &getVertex(int i) const; 
     47        inline const osg::Vec3& getVertex(int i) const; 
    4848         
    4949        /// Set a vertex. 
    50         inline void setVertex(int i, const osg::Vec3 &v); 
     50        inline void setVertex(int i, const osg::Vec3& v); 
    5151         
    5252        /// Set a vertex. 
     
    5454         
    5555        /// Add a vertex. 
    56         inline void addVertex(const osg::Vec3 &v); 
     56        inline void addVertex(const osg::Vec3& v); 
    5757         
    5858        /// Add a vertex. 
     
    6363         
    6464        /// Place a partice. Called automatically by <CODE>ModularEmitter</CODE>, do not call this method manually. 
    65         void place(Particle *P) const; 
     65        void place(Particle* P) const; 
    6666 
    6767    protected: 
    6868        virtual ~MultiSegmentPlacer() {} 
    69         MultiSegmentPlacer &operator=(const MultiSegmentPlacer &) { return *this; }         
     69        MultiSegmentPlacer& operator=(const MultiSegmentPlacer&) { return *this; }         
    7070 
    7171    private: 
     
    7373        typedef std::vector<Vertex_data> Vertex_vector; 
    7474         
    75         Vertex_vector vx_; 
    76         float total_length_; 
     75        Vertex_vector _vx; 
     76        float _total_length; 
    7777         
    7878        void recompute_length(); 
     
    8484    inline int MultiSegmentPlacer::numVertices() const 
    8585    { 
    86         return static_cast<int>(vx_.size()); 
     86        return static_cast<int>(_vx.size()); 
    8787    } 
    8888 
    89     inline const osg::Vec3 &MultiSegmentPlacer::getVertex(int i) const 
     89    inline const osg::Vec3& MultiSegmentPlacer::getVertex(int i) const 
    9090    { 
    91         return vx_[i].first; 
     91        return _vx[i].first; 
    9292    } 
    9393 
    94     inline void MultiSegmentPlacer::setVertex(int i, const osg::Vec3 &v) 
     94    inline void MultiSegmentPlacer::setVertex(int i, const osg::Vec3& v) 
    9595    { 
    96         vx_[i].first = v; 
     96        _vx[i].first = v; 
    9797        recompute_length(); 
    9898    } 
     
    100100    inline void MultiSegmentPlacer::setVertex(int i, float x, float y, float z) 
    101101    { 
    102         vx_[i].first.set(x, y, z); 
     102        _vx[i].first.set(x, y, z); 
    103103        recompute_length(); 
    104104    } 
    105105 
    106     inline void MultiSegmentPlacer::addVertex(const osg::Vec3 &v) 
     106    inline void MultiSegmentPlacer::addVertex(const osg::Vec3& v) 
    107107    { 
    108108        float l = 0;         
    109         if (vx_.size() > 0) { 
    110             l = (v - vx_.back().first).length(); 
     109        if (_vx.size() > 0) { 
     110            l = (v - _vx.back().first).length(); 
    111111        }                 
    112         total_length_ += l; 
    113         vx_.push_back(std::make_pair(v, total_length_));         
     112        _total_length += l; 
     113        _vx.push_back(std::make_pair(v, _total_length));         
    114114    } 
    115115 
     
    121121    inline void MultiSegmentPlacer::removeVertex(int i) 
    122122    { 
    123         vx_.erase(vx_.begin()+i); 
     123        _vx.erase(_vx.begin()+i); 
    124124        recompute_length(); 
    125125    } 
  • OpenSceneGraph/trunk/include/osgParticle/Operator

    r4038 r4121  
    1313//osgParticle - Copyright (C) 2002 Marco Jez 
    1414 
    15 #ifndef OSGPARTICLE_OPERATOR_ 
    16 #define OSGPARTICLE_OPERATOR_ 1 
     15#ifndef OSGPARTICLE_OPERATOR 
     16#define OSGPARTICLE_OPERATOR 1 
    1717 
    1818#include <osgParticle/Program> 
     
    3636    public: 
    3737        inline Operator(); 
    38         inline Operator(const Operator &copy, const osg::CopyOp &copyop = osg::CopyOp::SHALLOW_COPY); 
     38        inline Operator(const Operator& copy, const osg::CopyOp& copyop = osg::CopyOp::SHALLOW_COPY); 
    3939 
    40         virtual const char *libraryName() const { return "osgParticle"; } 
    41         virtual const char *className() const { return "Operator"; } 
    42         virtual bool isSameKindAs(const osg::Object *obj) const { return dynamic_cast<const Operator *>(obj) != 0; } 
     40        virtual const char* libraryName() const { return "osgParticle"; } 
     41        virtual const char* className() const { return "Operator"; } 
     42        virtual bool isSameKindAs(const osg::Object* obj) const { return dynamic_cast<const Operator* >(obj) != 0; } 
    4343         
    4444        /// Get whether this operator is enabled. 
     
    5454            the time elapsed from last operation.             
    5555        */ 
    56         virtual void operate(Particle *P, double dt) = 0; 
     56        virtual void operate(Particle* P, double dt) = 0; 
    5757         
    5858        /** Do something before processing particles via the <CODE>operate()</CODE> method. 
     
    7171         
    7272    private: 
    73         bool enabled_;         
     73        bool _enabled;         
    7474    }; 
    7575     
     
    7777     
    7878    inline Operator::Operator() 
    79     : osg::Object(), enabled_(true) 
     79    : osg::Object(), _enabled(true) 
    8080    { 
    8181    } 
    8282     
    83     inline Operator::Operator(const Operator &copy, const osg::CopyOp &copyop) 
    84     : osg::Object(copy, copyop), enabled_(copy.enabled_) 
     83    inline Operator::Operator(const Operator& copy, const osg::CopyOp& copyop) 
     84    : osg::Object(copy, copyop), _enabled(copy._enabled) 
    8585    { 
    8686    } 
     
    8888    inline bool Operator::isEnabled() const     
    8989    { 
    90         return enabled_; 
     90        return _enabled; 
    9191    } 
    9292     
    9393    inline void Operator::setEnabled(bool v) 
    9494    { 
    95         enabled_ = v; 
     95        _enabled = v; 
    9696    } 
    9797 
  • OpenSceneGraph/trunk/include/osgParticle/Particle

    r4038 r4121  
    1313//osgParticle - Copyright (C) 2002 Marco Jez 
    1414 
    15 #ifndef OSGPARTICLE_PARTICLE_ 
    16 #define OSGPARTICLE_PARTICLE_ 1 
     15#ifndef OSGPARTICLE_PARTICLE 
     16#define OSGPARTICLE_PARTICLE 1 
    1717 
    1818#include <osgParticle/Export> 
     
    5353            POINT,            // uses GL_POINTS as primitive 
    5454            QUAD,            // uses GL_QUADS as primitive 
    55             QUAD_TRIANGLESTRIP,    // uses GL_TRIANGLE_STRIP as primitive, but each particle needs a glBegin/glEnd pair 
     55            QUAD_TRIANGLESTRIP,    // uses GL_TRI_angleSTRIP as primitive, but each particle needs a glBegin/glEnd pair 
    5656            HEXAGON,            // may save some filling time, but uses more triangles 
    5757            LINE                // uses GL_LINES to draw line segments that point to the direction of motion             
     
    7676         
    7777        /// Get the minimum and maximum values for polygon size. 
    78         inline const rangef &getSizeRange() const; 
     78        inline const rangef& getSizeRange() const; 
    7979         
    8080        /// Get the minimum and maximum values for alpha. 
    81         inline const rangef &getAlphaRange() const; 
     81        inline const rangef& getAlphaRange() const; 
    8282         
    8383        /// Get the minimum and maximum values for color. 
    84         inline const rangev4 &getColorRange() const; 
     84        inline const rangev4& getColorRange() const; 
    8585         
    8686        /// Get the interpolator for computing the size of polygons. 
    87         inline const Interpolator *getSizeInterpolator() const; 
     87        inline const Interpolator* getSizeInterpolator() const; 
    8888         
    8989        /// Get the interpolator for computing alpha values. 
    90         inline const Interpolator *getAlphaInterpolator() const; 
     90        inline const Interpolator* getAlphaInterpolator() const; 
    9191         
    9292        /// Get the interpolator for computing color values. 
    93         inline const Interpolator *getColorInterpolator() const; 
     93        inline const Interpolator* getColorInterpolator() const; 
    9494 
    9595        /** Get the physical radius of the particle. 
     
    107107         
    108108        /// Get the position vector. 
    109         inline const osg::Vec3 &getPosition() const; 
     109        inline const osg::Vec3& getPosition() const; 
    110110         
    111111        /**    Get the velocity vector. 
     
    113113            in meters per second. 
    114114        */ 
    115         inline const osg::Vec3 &getVelocity() const;         
     115        inline const osg::Vec3& getVelocity() const;         
    116116         
    117117        /// Get the previous position (the position before last update). 
    118         inline const osg::Vec3 &getPreviousPosition() const; 
     118        inline const osg::Vec3& getPreviousPosition() const; 
    119119 
    120120        /// Get the angle vector. 
    121         inline const osg::Vec3 &getAngle() const; 
     121        inline const osg::Vec3& getAngle() const; 
    122122         
    123123        /// Get the rotational velocity vector. 
    124         inline const osg::Vec3 &getAngularVelocity() const; 
     124        inline const osg::Vec3& getAngularVelocity() const; 
    125125         
    126126        /// Get the previous angle vector. 
    127         inline const osg::Vec3 &getPreviousAngle() const; 
     127        inline const osg::Vec3& getPreviousAngle() const; 
    128128 
    129129        /** Kill the particle on next update 
     
    137137         
    138138        /// Set the minimum and maximum values for polygon size. 
    139         inline void setSizeRange(const rangef &r); 
     139        inline void setSizeRange(const rangef& r); 
    140140         
    141141        /// Set the minimum and maximum values for alpha. 
    142         inline void setAlphaRange(const rangef &r); 
     142        inline void setAlphaRange(const rangef& r); 
    143143         
    144144        /// Set the minimum and maximum values for color. 
    145         inline void setColorRange(const rangev4 &r); 
     145        inline void setColorRange(const rangev4& r); 
    146146         
    147147        /// Set the interpolator for computing size values. 
    148         inline void setSizeInterpolator(Interpolator *ri); 
     148        inline void setSizeInterpolator(Interpolator* ri); 
    149149         
    150150        /// Set the interpolator for computing alpha values.         
    151         inline void setAlphaInterpolator(Interpolator *ai); 
     151        inline void setAlphaInterpolator(Interpolator* ai); 
    152152         
    153153        /// Set the interpolator for computing color values. 
    154         inline void setColorInterpolator(Interpolator *ci); 
     154        inline void setColorInterpolator(Interpolator* ci); 
    155155 
    156156        /** Set the physical radius of the particle. 
     
    165165         
    166166        /// Set the position vector.         
    167         inline void setPosition(const osg::Vec3 &p); 
     167        inline void setPosition(const osg::Vec3& p); 
    168168         
    169169        /**    Set the velocity vector. 
     
    171171            in meters per second. 
    172172        */ 
    173         inline void setVelocity(const osg::Vec3 &v); 
     173        inline void setVelocity(const osg::Vec3& v); 
    174174         
    175175        /// Add a vector to the velocity vector. 
    176         inline void addVelocity(const osg::Vec3 &dv); 
     176        inline void addVelocity(const osg::Vec3& dv); 
    177177         
    178178        /// Transform position and velocity vectors by a matrix. 
    179         inline void transformPositionVelocity(const osg::Matrix &xform); 
     179        inline void transformPositionVelocity(const osg::Matrix& xform); 
    180180 
    181181        /// Set the angle vector. 
    182         inline void setAngle(const osg::Vec3 &a); 
     182        inline void setAngle(const osg::Vec3& a); 
    183183         
    184184        /** 
     
    186186          Components x, y and z are angles of rotation around the respective axis (in radians). 
    187187        */ 
    188         inline void setAngularVelocity(const osg::Vec3 &v); 
     188        inline void setAngularVelocity(const osg::Vec3& v); 
    189189         
    190190        /// Add a vector to the angular velocity vector. 
    191         inline void addAngularVelocity(const osg::Vec3 &dv); 
     191        inline void addAngularVelocity(const osg::Vec3& dv); 
    192192         
    193193        /// Transform angle and angularVelocity vectors by a matrix. 
    194         inline void transformAngleVelocity(const osg::Matrix &xform); 
     194        inline void transformAngleVelocity(const osg::Matrix& xform); 
    195195         
    196196        /**    Update the particle (don't call this method manually). 
     
    206206         
    207207        /// Render the particle. Called automatically by particle systems. 
    208         void render(const osg::Vec3 &xpos, const osg::Vec3 &px, const osg::Vec3 &py, float scale = 1.0f) const; 
     208        void render(const osg::Vec3& xpos, const osg::Vec3& px, const osg::Vec3& py, float scale = 1.0f) const; 
    209209         
    210210        /// Perform some post-rendering tasks. Called automatically by particle systems. 
     
    218218 
    219219    private: 
    220         Shape shape_; 
    221  
    222         rangef sr_; 
    223         rangef ar_; 
    224         rangev4 cr_; 
    225  
    226         osg::ref_ptr<Interpolator> si_; 
    227         osg::ref_ptr<Interpolator> ai_; 
    228         osg::ref_ptr<Interpolator> ci_; 
    229  
    230         bool alive_; 
    231         bool mustdie_; 
    232         double lifetime_; 
    233  
    234         float radius_; 
    235         float mass_; 
    236         float massinv_; 
    237         osg::Vec3 prev_pos_; 
    238         osg::Vec3 position_; 
    239         osg::Vec3 velocity_; 
    240  
    241         osg::Vec3 prev_angle_; 
    242         osg::Vec3 angle_; 
    243         osg::Vec3 angular_vel_; 
    244  
    245         double t0_;         
    246  
    247         float current_size_; 
    248         float current_alpha_; 
    249         osg::Vec4 current_color_; 
    250          
    251         float s_tile_; 
    252         float t_tile_; 
    253         int num_tile_; 
    254         int cur_tile_; 
    255         float s_coord_; 
    256         float t_coord_; 
     220        Shape _shape; 
     221 
     222        rangef _sr; 
     223        rangef _ar; 
     224        rangev4 _cr; 
     225 
     226        osg::ref_ptr<Interpolator> _si; 
     227        osg::ref_ptr<Interpolator> _ai; 
     228        osg::ref_ptr<Interpolator> _ci; 
     229 
     230        bool _alive; 
     231        bool _mustdie; 
     232        double _lifeTime; 
     233 
     234        float _radius; 
     235        float _mass; 
     236        float _massinv; 
     237        osg::Vec3 _prev_pos; 
     238        osg::Vec3 _position; 
     239        osg::Vec3 _velocity; 
     240 
     241        osg::Vec3 _prev_angle; 
     242        osg::Vec3 _angle; 
     243        osg::Vec3 _angul_arvel; 
     244 
     245        double _t0;         
     246 
     247        float _current_size; 
     248        float _current_alpha; 
     249        osg::Vec4 _current_color; 
     250         
     251        float _s_tile; 
     252        float _t_tile; 
     253        int _num_tile; 
     254        int _cur_tile; 
     255        float _s_coord; 
     256        float _t_coord; 
    257257    }; 
    258258 
     
    261261    inline Particle::Shape Particle::getShape() const 
    262262    { 
    263         return shape_; 
     263        return _shape; 
    264264    } 
    265265 
    266266    inline void Particle::setShape(Shape s) 
    267267    { 
    268         shape_ = s; 
     268        _shape = s; 
    269269    } 
    270270 
    271271    inline bool Particle::isAlive() const 
    272272    { 
    273         return alive_; 
     273        return _alive; 
    274274    } 
    275275 
    276276    inline double Particle::getLifeTime() const 
    277277    { 
    278         return lifetime_; 
     278        return _lifeTime; 
    279279    } 
    280280     
    281281    inline double Particle::getAge() const 
    282282    { 
    283         return t0_; 
     283        return _t0; 
    284284    } 
    285285     
    286286    inline float Particle::getRadius() const 
    287287    { 
    288         return radius_; 
     288        return _radius; 
    289289    } 
    290290     
    291291    inline void Particle::setRadius(float r) 
    292292    { 
    293         radius_ = r; 
    294     } 
    295  
    296     inline const rangef &Particle::getSizeRange() const 
    297     { 
    298         return sr_; 
    299     } 
    300  
    301     inline const rangef &Particle::getAlphaRange() const 
    302     { 
    303         return ar_; 
    304     } 
    305  
    306     inline const rangev4 &Particle::getColorRange() const 
    307     { 
    308         return cr_; 
    309     } 
    310  
    311     inline const Interpolator *Particle::getSizeInterpolator() const 
    312     { 
    313         return si_.get(); 
    314     } 
    315  
    316     inline const Interpolator *Particle::getAlphaInterpolator() const 
    317     { 
    318         return ai_.get(); 
    319     } 
    320  
    321     inline const Interpolator *Particle::getColorInterpolator() const 
    322     { 
    323         return ci_.get(); 
    324     } 
    325  
    326     inline const osg::Vec3 &Particle::getPosition() const 
    327     { 
    328         return position_; 
    329     } 
    330  
    331     inline const osg::Vec3 &Particle::getVelocity() const 
    332     { 
    333         return velocity_; 
    334     } 
    335      
    336     inline const osg::Vec3 &Particle::getPreviousPosition() const 
    337     { 
    338         return prev_pos_; 
    339     } 
    340  
    341     inline const osg::Vec3 &Particle::getAngle() const 
    342     { 
    343         return angle_; 
    344     } 
    345      
    346     inline const osg::Vec3 &Particle::getAngularVelocity() const 
    347     { 
    348         return angular_vel_; 
    349     } 
    350      
    351     inline const osg::Vec3 &Particle::getPreviousAngle() const 
    352     { 
    353         return prev_angle_; 
     293        _radius = r; 
     294    } 
     295 
     296    inline const rangef& Particle::getSizeRange() const 
     297    { 
     298        return _sr; 
     299    } 
     300 
     301    inline const rangef& Particle::getAlphaRange() const 
     302    { 
     303        return _ar; 
     304    } 
     305 
     306    inline const rangev4& Particle::getColorRange() const 
     307    { 
     308        return _cr; 
     309    } 
     310 
     311    inline const Interpolator* Particle::getSizeInterpolator() const 
     312    { 
     313        return _si.get(); 
     314    } 
     315 
     316    inline const Interpolator* Particle::getAlphaInterpolator() const 
     317    { 
     318        return _ai.get(); 
     319    } 
     320 
     321    inline const Interpolator* Particle::getColorInterpolator() const 
     322    { 
     323        return _ci.get(); 
     324    } 
     325 
     326    inline const osg::Vec3& Particle::getPosition() const 
     327    { 
     328        return _position; 
     329    } 
     330 
     331    inline const osg::Vec3& Particle::getVelocity() const 
     332    { 
     333        return _velocity; 
     334    } 
     335     
     336    inline const osg::Vec3& Particle::getPreviousPosition() const 
     337    { 
     338        return _prev_pos; 
     339    } 
     340 
     341    inline const osg::Vec3& Particle::getAngle() const 
     342    { 
     343        return _angle; 
     344    } 
     345     
     346    inline const osg::Vec3& Particle::getAngularVelocity() const 
     347    { 
     348        return _angul_arvel; 
     349    } 
     350     
     351    inline const osg::Vec3& Particle::getPreviousAngle() const 
     352    { 
     353        return _prev_angle; 
    354354    } 
    355355     
    356356    inline void Particle::kill() 
    357357    { 
    358         mustdie_ = true; 
     358        _mustdie = true; 
    359359    } 
    360360 
    361361    inline void Particle::setLifeTime(double t) 
    362362    { 
    363         lifetime_ = t; 
    364     } 
    365  
    366     inline void Particle::setSizeRange(const rangef &r) 
    367     { 
    368         sr_ = r; 
    369     } 
    370  
    371     inline void Particle::setAlphaRange(const rangef &r) 
    372     { 
    373         ar_ = r; 
    374     } 
    375  
    376     inline void Particle::setColorRange(const rangev4 &r) 
    377     { 
    378         cr_ = r; 
    379     } 
    380  
    381     inline void Particle::setSizeInterpolator(Interpolator *ri) 
    382     { 
    383         si_ = ri; 
    384     } 
    385  
    386     inline void Particle::setAlphaInterpolator(Interpolator *ai) 
    387     { 
    388         ai_ = ai; 
    389     } 
    390  
    391     inline void Particle::setColorInterpolator(Interpolator *ci) 
    392     { 
    393         ci_ = ci; 
    394     } 
    395  
    396     inline void Particle::setPosition(const osg::Vec3 &p) 
    397     { 
    398         position_ = p; 
    399     } 
    400  
    401     inline void Particle::setVelocity(const osg::Vec3 &v) 
    402     { 
    403         velocity_ = v; 
    404     } 
    405  
    406     inline void Particle::addVelocity(const osg::Vec3 &dv) 
    407     { 
    408         velocity_ += dv; 
    409     } 
    410  
    411     inline void Particle::transformPositionVelocity(const osg::Matrix &xform) 
     363        _lifeTime = t; 
     364    } 
     365 
     366    inline void Particle::setSizeRange(const rangef& r) 
     367    { 
     368        _sr = r; 
     369    } 
     370 
     371    inline void Particle::setAlphaRange(const rangef& r) 
     372    { 
     373        _ar = r; 
     374    } 
     375 
     376    inline void Particle::setColorRange(const rangev4& r) 
     377    { 
     378        _cr = r; 
     379    } 
     380 
     381    inline void Particle::setSizeInterpolator(Interpolator* ri) 
     382    { 
     383        _si = ri; 
     384    } 
     385 
     386    inline void Particle::setAlphaInterpolator(Interpolator* ai) 
     387    { 
     388        _ai = ai; 
     389    } 
     390 
     391    inline void Particle::setColorInterpolator(Interpolator* ci) 
     392    { 
     393        _ci = ci; 
     394    } 
     395 
     396    inline void Particle::setPosition(const osg::Vec3& p) 
     397    { 
     398        _position = p; 
     399    } 
     400 
     401    inline void Particle::setVelocity(const osg::Vec3& v) 
     402    { 
     403        _velocity = v; 
     404    } 
     405 
     406    inline void Particle::addVelocity(const osg::Vec3& dv) 
     407    { 
     408        _velocity += dv; 
     409    } 
     410 
     411    inline void Particle::transformPositionVelocity(const osg::Matrix& xform) 
    412412    { 
    413413        // this should be optimized! 
    414414 
    415         osg::Vec3 p1 = position_ + velocity_; 
     415        osg::Vec3 p1 = _position + _velocity; 
    416416                 
    417         position_ = xform.preMult(position_); 
     417        _position = xform.preMult(_position); 
    418418        p1 = xform.preMult(p1); 
    419419         
    420         velocity_ = p1 - position_; 
    421     } 
    422      
    423     inline void Particle::setAngle(const osg::Vec3 &a) 
    424     { 
    425         angle_ = a; 
    426     } 
    427      
    428     inline void Particle::setAngularVelocity(const osg::Vec3 &v) 
    429     { 
    430         angular_vel_ = v; 
    431     } 
    432      
    433     inline void Particle::addAngularVelocity(const osg::Vec3 &dv) 
    434     { 
    435         angular_vel_ += dv; 
    436     } 
    437      
    438     inline void Particle::transformAngleVelocity(const osg::Matrix &xform) 
     420        _velocity = p1 - _position; 
     421    } 
     422     
     423    inline void Particle::setAngle(const osg::Vec3& a) 
     424    { 
     425        _angle = a; 
     426    } 
     427     
     428    inline void Particle::setAngularVelocity(const osg::Vec3& v) 
     429    { 
     430        _angul_arvel = v; 
     431    } 
     432     
     433    inline void Particle::addAngularVelocity(const osg::Vec3& dv) 
     434    { 
     435        _angul_arvel += dv; 
     436    } 
     437     
     438    inline void Particle::transformAngleVelocity(const osg::Matrix& xform) 
    439439    { 
    440440        // this should be optimized! 
    441441         
    442         osg::Vec3 a1 = angle_ + angular_vel_; 
    443          
    444         angle_ = xform.preMult(angle_); 
     442        osg::Vec3 a1 = _angle + _angul_arvel; 
     443         
     444        _angle = xform.preMult(_angle); 
    445445        a1 = xform.preMult(a1); 
    446446         
    447         angular_vel_ = a1 - angle_; 
     447        _angul_arvel = a1 - _angle; 
    448448    } 
    449449             
    450450    inline float Particle::getMass() const 
    451451    { 
    452         return mass_; 
     452        return _mass; 
    453453    } 
    454454     
    455455    inline float Particle::getMassInv() const 
    456456    { 
    457         return massinv_; 
     457        return _massinv; 
    458458    } 
    459459     
    460460    inline void Particle::setMass(float m) 
    461461    { 
    462         mass_ = m; 
    463         massinv_ = 1 / m; 
     462        _mass = m; 
     463        _massinv = 1 / m; 
    464464    } 
    465465     
    466466    inline void Particle::beginRender() const 
    467467    { 
    468         switch (shape_) 
     468        switch (_shape) 
    469469        { 
    470470        case POINT: 
     
    483483    inline void Particle::endRender() const 
    484484    { 
    485         switch (shape_) 
     485        switch (_shape) 
    486486        {         
    487487        case POINT: 
     
    496496    inline float Particle::getCurrentSize() const 
    497497    { 
    498         return current_size_; 
     498        return _current_size; 
    499499    } 
    500500     
    501501    inline void Particle::setTextureTile(int sTile, int tTile, int numTiles) 
    502502    { 
    503         s_tile_ = 1.0f / static_cast<float>(sTile); 
    504         t_tile_ = 1.0f / static_cast<float>(tTile); 
     503        _s_tile = 1.0f / static_cast<float>(sTile); 
     504        _t_tile = 1.0f / static_cast<float>(tTile); 
    505505        if (numTiles <= 0) 
    506506        { 
    507             num_tile_ = sTile * tTile; 
     507            _num_tile = sTile * tTile; 
    508508        } 
    509509        else 
    510510        { 
    511             num_tile_ = numTiles; 
     511            _num_tile = numTiles; 
    512512        } 
    513513    } 
  • OpenSceneGraph/trunk/include/osgParticle/ParticleEffect

    r4038 r4121  
    3838 
    3939 
    40         virtual const char *libraryName() const { return "osgParticle"; } 
    41         virtual const char *className() const { return "ParticleEffect"; } 
    42         virtual bool isSameKindAs(const osg::Object *obj) const { return dynamic_cast<const ParticleEffect*>(obj) != 0; } 
     40        virtual const char* libraryName() const { return "osgParticle"; } 
     41        virtual const char* className() const { return "ParticleEffect"; } 
     42        virtual bool isSameKindAs(const osg::Object* obj) const { return dynamic_cast<const ParticleEffect*>(obj) != 0; } 
    4343        virtual void accept(osg::NodeVisitor& nv) { if (nv.validNodeMask(*this)) { nv.pushOntoNodePath(this); nv.apply(*this); nv.popFromNodePath(); } } 
    4444 
  • OpenSceneGraph/trunk/include/osgParticle/ParticleProcessor

    r4038 r4121  
    1313//osgParticle - Copyright (C) 2002 Marco Jez 
    1414 
    15 #ifndef OSGPARTICLE_PARTICLEPROCESSOR_ 
    16 #define OSGPARTICLE_PARTICLEPROCESSOR_ 1 
     15#ifndef OSGPARTICLE_PARTICLEPROCESSOR 
     16#define OSGPARTICLE_PARTICLEPROCESSOR 1 
    1717 
    1818#include <osgParticle/Export> 
     
    4242            RELATIVE_RF, 
    4343            ABSOLUTE_RF 
    44 #ifdef USE_DEPRECATED_API 
    45             , 
    46             RELATIVE_RF_TO_PARENTS=RELATIVE_RF, 
    47             RELATIVE_RF_TO_ABSOLUTE=ABSOLUTE_RF, 
    48 #endif 
    4944        }; 
    5045         
    5146        ParticleProcessor(); 
    52         ParticleProcessor(const ParticleProcessor &copy, const osg::CopyOp &copyop = osg::CopyOp::SHALLOW_COPY); 
    53  
    54         virtual const char *libraryName() const { return "osgParticle"; } 
    55         virtual const char *className() const { return "ParticleProcessor"; } 
    56         virtual bool isSameKindAs(const osg::Object *obj) const { return dynamic_cast<const ParticleProcessor*>(obj) != 0; } 
     47        ParticleProcessor(const ParticleProcessor& copy, const osg::CopyOp& copyop = osg::CopyOp::SHALLOW_COPY); 
     48 
     49        virtual const char* libraryName() const { return "osgParticle"; } 
     50        virtual const char* className() const { return "ParticleProcessor"; } 
     51        virtual bool isSameKindAs(const osg::Object* obj) const { return dynamic_cast<const ParticleProcessor*>(obj) != 0; } 
    5752        virtual void accept(osg::NodeVisitor& nv) { if (nv.validNodeMask(*this)) { nv.pushOntoNodePath(this); nv.apply(*this); nv.popFromNodePath(); } }         
    5853         
     
    7065         
    7166        /// Get a pointer to the destination particle system. 
    72         inline ParticleSystem *getParticleSystem(); 
     67        inline ParticleSystem* getParticleSystem(); 
    7368         
    7469        /// Get a const pointer to the destination particle system. 
    75         inline const ParticleSystem *getParticleSystem() const; 
     70        inline const ParticleSystem* getParticleSystem() const; 
    7671         
    7772        /// Set the destination particle system. 
    78         inline void setParticleSystem(ParticleSystem *ps); 
     73        inline void setParticleSystem(ParticleSystem* ps); 
    7974         
    8075        /// Set the endless flag of this processor. 
     
    117112        inline bool isAlive() const; 
    118113         
    119         void traverse(osg::NodeVisitor &nv); 
     114        void traverse(osg::NodeVisitor& nv); 
    120115 
    121116        /// Get the current local-to-world transformation matrix (valid only during cull traversal). 
    122         inline const osg::Matrix &getLocalToWorldMatrix(); 
     117        inline const osg::Matrix& getLocalToWorldMatrix(); 
    123118         
    124119        /// Get the current world-to-local transformation matrix (valid only during cull traversal). 
    125         inline const osg::Matrix &getWorldToLocalMatrix(); 
     120        inline const osg::Matrix& getWorldToLocalMatrix(); 
    126121         
    127122        /// Transform a point from local to world coordinates (valid only during cull traversal). 
    128         inline osg::Vec3 transformLocalToWorld(const osg::Vec3 &P); 
     123        inline osg::Vec3 transformLocalToWorld(const osg::Vec3& P); 
    129124         
    130125        /// Transform a vector from local to world coordinates, discarding translation (valid only during cull traversal). 
    131         inline osg::Vec3 rotateLocalToWorld(const osg::Vec3 &P); 
     126        inline osg::Vec3 rotateLocalToWorld(const osg::Vec3& P); 
    132127         
    133128        /// Transform a point from world to local coordinates (valid only during cull traversal). 
    134         inline osg::Vec3 transformWorldToLocal(const osg::Vec3 &P); 
     129        inline osg::Vec3 transformWorldToLocal(const osg::Vec3& P); 
    135130         
    136131        /// Transform a vector from world to local coordinates, discarding translation (valid only during cull traversal). 
    137         inline osg::Vec3 rotateWorldToLocal(const osg::Vec3 &P); 
     132        inline osg::Vec3 rotateWorldToLocal(const osg::Vec3& P); 
    138133 
    139134    protected: 
    140135        virtual ~ParticleProcessor() {} 
    141         ParticleProcessor &operator=(const ParticleProcessor &) { return *this; } 
     136        ParticleProcessor& operator=(const ParticleProcessor&) { return *this; } 
    142137         
    143138        inline bool computeBound() const;     
     
    146141         
    147142    private: 
    148         ReferenceFrame rf_; 
    149         bool enabled_; 
    150         double t0_; 
    151         osg::ref_ptr<ParticleSystem> ps_; 
    152         bool need_ltw_matrix_; 
    153         bool need_wtl_matrix_; 
    154         osg::Matrix ltw_matrix_; 
    155         osg::Matrix wtl_matrix_; 
    156         osg::NodeVisitor *current_nodevisitor_; 
    157          
    158         bool endless_; 
    159          
    160         double lifeTime_; 
    161         double startTime_; 
    162         double currentTime_; 
    163         double resetTime_; 
     143        ReferenceFrame _rf; 
     144        bool _enabled; 
     145        double _t0; 
     146        osg::ref_ptr<ParticleSystem> _ps; 
     147        bool _need_ltw_matrix; 
     148        bool _need_wtl_matrix; 
     149        osg::Matrix _ltw_matrix; 
     150        osg::Matrix _wtl_matrix; 
     151        osg::NodeVisitor* _current_nodevisitor; 
     152         
     153        bool _endless; 
     154         
     155        double _lifeTime; 
     156        double _startTime; 
     157        double _currentTime; 
     158        double _resetTime; 
    164159    }; 
    165160     
     
    168163    inline ParticleProcessor::ReferenceFrame ParticleProcessor::getReferenceFrame() const 
    169164    { 
    170         return rf_; 
     165        return _rf; 
    171166    } 
    172167     
    173168    inline void ParticleProcessor::setReferenceFrame(ReferenceFrame rf) 
    174169    { 
    175         rf_ = rf; 
     170        _rf = rf; 
    176171    } 
    177172     
    178173    inline bool ParticleProcessor::isEnabled() const 
    179174    { 
    180         return enabled_; 
     175        return _enabled; 
    181176    } 
    182177     
    183178    inline void ParticleProcessor::setEnabled(bool v) 
    184179    { 
    185         enabled_ = v; 
    186         if (enabled_) { 
    187                         t0_ = -1; 
    188                         currentTime_ = 0; 
    189                 } 
    190     } 
    191      
    192     inline ParticleSystem *ParticleProcessor::getParticleSystem() 
    193     { 
    194         return ps_.get(); 
    195     } 
    196  
    197     inline const ParticleSystem *ParticleProcessor::getParticleSystem() const 
    198     { 
    199         return ps_.get(); 
    200     } 
    201      
    202     inline void ParticleProcessor::setParticleSystem(ParticleSystem *ps) 
    203     { 
    204         ps_ = ps; 
     180        _enabled = v; 
     181        if (_enabled) 
     182        { 
     183            _t0 = -1; 
     184            _currentTime = 0; 
     185        } 
     186    } 
     187     
     188    inline ParticleSystem* ParticleProcessor::getParticleSystem() 
     189    { 
     190        return _ps.get(); 
     191    } 
     192 
     193    inline const ParticleSystem* ParticleProcessor::getParticleSystem() const 
     194    { 
     195        return _ps.get(); 
     196    } 
     197     
     198    inline void ParticleProcessor::setParticleSystem(ParticleSystem* ps) 
     199    { 
     200        _ps = ps; 
    205201    } 
    206202    
    207203    inline void ParticleProcessor::setEndless(bool type) 
    208204    { 
    209                 endless_ = type; 
     205        _endless = type; 
    210206    } 
    211207         
    212208    inline bool ParticleProcessor::isEndless() const 
    213209    { 
    214                 return endless_; 
     210        return _endless; 
    215211    } 
    216212 
    217213    inline void ParticleProcessor::setLifeTime(double t) 
    218214    { 
    219                 lifeTime_ = t; 
    220         } 
     215        _lifeTime = t; 
     216    } 
    221217         
    222218    inline double ParticleProcessor::getLifeTime() const 
    223219    { 
    224                 return lifeTime_; 
    225         } 
    226             
     220        return _lifeTime; 
     221    } 
     222        
    227223    inline void ParticleProcessor::setStartTime(double t) 
    228224    { 
    229                 startTime_ = t; 
    230         } 
     225        _startTime = t; 
     226    } 
    231227         
    232228    inline double ParticleProcessor::getStartTime() const 
    233229    { 
    234                 return startTime_; 
    235         } 
     230        return _startTime; 
     231    } 
    236232    inline void ParticleProcessor::setCurrentTime(double t) 
    237233    { 
    238                 currentTime_ = t; 
    239         } 
     234        _currentTime = t; 
     235    } 
    240236         
    241237    inline double ParticleProcessor::getCurrentTime() const 
    242238    { 
    243                 return currentTime_; 
    244         } 
    245          
    246         inline void ParticleProcessor::setResetTime(double t) 
    247         { 
    248                 resetTime_ = t; 
    249         } 
    250          
    251         inline double ParticleProcessor::getResetTime() const 
    252         { 
    253                 return resetTime_; 
    254         } 
     239        return _currentTime; 
     240    } 
     241     
     242    inline void ParticleProcessor::setResetTime(double t) 
     243    { 
     244        _resetTime = t; 
     245    } 
     246     
     247    inline double ParticleProcessor::getResetTime() const 
     248    { 
     249        return _resetTime; 
     250    } 
    255251 
    256252    inline bool ParticleProcessor::computeBound() const 
     
    261257    } 
    262258     
    263     inline const osg::Matrix &ParticleProcessor::getLocalToWorldMatrix()     
    264     { 
    265         if (need_ltw_matrix_) { 
    266             ltw_matrix_ = osg::Matrix::identity(); 
    267             //current_nodevisitor_->getLocalToWorldMatrix(ltw_matrix_, this); 
    268             ltw_matrix_ = osg::computeLocalToWorld(current_nodevisitor_->getNodePath()); 
    269             need_ltw_matrix_ = false; 
     259    inline const osg::Matrix& ParticleProcessor::getLocalToWorldMatrix()     
     260    { 
     261        if (_need_ltw_matrix) { 
     262            _ltw_matrix = osg::Matrix::identity(); 
     263            //_current_nodevisitor->getLocalToWorldMatrix(_ltw_matrix, this); 
     264            _ltw_matrix = osg::computeLocalToWorld(_current_nodevisitor->getNodePath()); 
     265            _need_ltw_matrix = false; 
    270266        } 
    271         return ltw_matrix_; 
    272     } 
    273  
    274     inline const osg::Matrix &ParticleProcessor::getWorldToLocalMatrix()     
    275     { 
    276         if (need_wtl_matrix_) { 
    277             wtl_matrix_ = osg::Matrix::identity(); 
    278             //current_nodevisitor_->getWorldToLocalMatrix(wtl_matrix_, this); 
    279             wtl_matrix_ = osg::computeWorldToLocal(current_nodevisitor_->getNodePath()); 
    280             need_wtl_matrix_ = false; 
     267        return _ltw_matrix; 
     268    } 
     269 
     270    inline const osg::Matrix& ParticleProcessor::getWorldToLocalMatrix()     
     271    { 
     272        if (_need_wtl_matrix) { 
     273            _wtl_matrix = osg::Matrix::identity(); 
     274            //_current_nodevisitor->getWorldToLocalMatrix(_wtl_matrix, this); 
     275            _wtl_matrix = osg::computeWorldToLocal(_current_nodevisitor->getNodePath()); 
     276            _need_wtl_matrix = false; 
    281277        } 
    282         return wtl_matrix_; 
    283     } 
    284      
    285     inline osg::Vec3 ParticleProcessor::transformLocalToWorld(const osg::Vec3 &P) 
     278        return _wtl_matrix; 
     279    } 
     280     
     281    inline osg::Vec3 ParticleProcessor::transformLocalToWorld(const osg::Vec3& P) 
    286282    { 
    287283        return getLocalToWorldMatrix().preMult(P); 
    288284    } 
    289285     
    290     inline osg::Vec3 ParticleProcessor::transformWorldToLocal(const osg::Vec3 &P) 
     286    inline osg::Vec3 ParticleProcessor::transformWorldToLocal(const osg::Vec3& P) 
    291287    { 
    292288        return getWorldToLocalMatrix().preMult(P); 
    293289    } 
    294290 
    295     inline osg::Vec3 ParticleProcessor::rotateLocalToWorld(const osg::Vec3 &P) 
     291    inline osg::Vec3 ParticleProcessor::rotateLocalToWorld(const osg::Vec3& P) 
    296292    { 
    297293        return getLocalToWorldMatrix().preMult(P) -  
     
    299295    } 
    300296     
    301     inline osg::Vec3 ParticleProcessor::rotateWorldToLocal(const osg::Vec3 &P) 
     297    inline osg::Vec3 ParticleProcessor::rotateWorldToLocal(const osg::Vec3& P) 
    302298    { 
    303299        return getWorldToLocalMatrix().preMult(P) - 
     
    307303    inline bool ParticleProcessor::isAlive() const 
    308304    { 
    309                 return currentTime_ < (lifeTime_ + startTime_); 
     305        return _currentTime < (_lifeTime + _startTime); 
    310306    } 
    311307 
  • OpenSceneGraph/trunk/include/osgParticle/ParticleSystem

    r4038 r4121  
    1313//osgParticle - Copyright (C) 2002 Marco Jez 
    1414 
    15 #ifndef OSGPARTICLE_PARTICLESYSTEM_ 
    16 #define OSGPARTICLE_PARTICLESYSTEM_ 1 
     15#ifndef OSGPARTICLE_PARTICLESYSTEM 
     16#define OSGPARTICLE_PARTICLESYSTEM 1 
    1717 
    1818#include <osgParticle/Export> 
     
    4949 
    5050        ParticleSystem(); 
    51         ParticleSystem(const ParticleSystem &copy, const osg::CopyOp &copyop = osg::CopyOp::SHALLOW_COPY); 
     51        ParticleSystem(const ParticleSystem& copy, const osg::CopyOp& copyop = osg::CopyOp::SHALLOW_COPY); 
    5252 
    5353        META_Object(osgParticle, ParticleSystem); 
     
    6060         
    6161        /// Get the X-axis alignment vector. 
    62         inline const osg::Vec3 &getAlignVectorX() const; 
     62        inline const osg::Vec3& getAlignVectorX() const; 
    6363         
    6464        /// Set the X-axis alignment vector. 
    65         inline void setAlignVectorX(const osg::Vec3 &v); 
     65        inline void setAlignVectorX(const osg::Vec3& v); 
    6666 
    6767        /// Get the Y-axis alignment vector. 
    68         inline const osg::Vec3 &getAlignVectorY() const; 
     68        inline const osg::Vec3& getAlignVectorY() const; 
    6969         
    7070        /// Set the Y-axis alignment vector. 
    71         inline void setAlignVectorY(const osg::Vec3 &v); 
     71        inline void setAlignVectorY(const osg::Vec3& v); 
    7272         
    7373        /// Set the alignment vectors. 
    74         inline void setAlignVectors(const osg::Vec3 &X, const osg::Vec3 &Y); 
     74        inline void setAlignVectors(const osg::Vec3& X, const osg::Vec3& Y); 
    7575 
    7676        /// Get the default bounding box 
    77         inline const osg::BoundingBox &getDefaultBoundingBox() const;         
     77        inline const osg::BoundingBox& getDefaultBoundingBox() const;         
    7878         
    7979        /**    Set the default bounding box. 
     
    8181            because no particles has been updated yet. 
    8282        */ 
    83         inline void setDefaultBoundingBox(const osg::BoundingBox &bbox); 
     83        inline void setDefaultBoundingBox(const osg::BoundingBox& bbox); 
    8484 
    8585        /// Get the double pass rendering flag. 
     
    113113         
    114114        /// Get a pointer to the i-th particle. 
    115         inline Particle *getParticle(int i); 
     115        inline Particle* getParticle(int i); 
    116116         
    117117        /// Get a const pointer to the i-th particle. 
    118         inline const Particle *getParticle(int i) const; 
     118        inline const Particle* getParticle(int i) const; 
    119119         
    120120        /// Create a new particle from the specified template (or the default one if <CODE>ptemplate</CODE> is null). 
    121         inline virtual Particle *createParticle(const Particle *ptemplate); 
     121        inline virtual Particle* createParticle(const Particle* ptemplate); 
    122122         
    123123        /// Destroy the i-th particle. 
     
    128128 
    129129        /// Get a reference to the default particle template. 
    130         inline Particle &getDefaultParticleTemplate(); 
     130        inline Particle& getDefaultParticleTemplate(); 
    131131         
    132132        /// Get a const reference to the default particle template. 
    133         inline const Particle &getDefaultParticleTemplate() const; 
     133        inline const Particle& getDefaultParticleTemplate() const; 
    134134 
    135135        /// Set the default particle template (particle is copied). 
    136         inline void setDefaultParticleTemplate(const Particle &p); 
     136        inline void setDefaultParticleTemplate(const Particle& p); 
    137137         
    138138        /// Get whether the particle system can freeze when culled 
     
    145145            If <CODE>texturefile</CODE> is empty, then texturing is turned off. 
    146146        */ 
    147         void setDefaultAttributes(const std::string &texturefile = "", bool emissive_particles = true, bool lighting = false, int texture_unit = 0); 
     147        void setDefaultAttributes(const std::string& texturefile = "", bool emissive_particles = true, bool lighting = false, int texture_unit = 0); 
    148148         
    149149        /// (<B>EXPERIMENTAL</B>) Get the level of detail. 
     
    158158        virtual void update(double dt); 
    159159 
    160         virtual void drawImplementation(osg::State &state) const; 
     160        virtual void drawImplementation(osg::State& state) const; 
    161161 
    162162    protected: 
     
    164164        virtual ~ParticleSystem(); 
    165165 
    166         ParticleSystem &operator=(const ParticleSystem &) { return *this; } 
     166        ParticleSystem& operator=(const ParticleSystem&) { return *this; } 
    167167 
    168168        inline virtual bool computeBound() const; 
    169         inline void update_bounds(const osg::Vec3 &p, float r); 
    170         void single_pass_render(osg::State &state, const osg::Matrix &modelview) const; 
     169        inline void update_bounds(const osg::Vec3& p, float r); 
     170        void single_pass_render(osg::State& state, const osg::Matrix& modelview) const; 
    171171 
    172172    private: 
     
    174174        typedef std::stack<Particle*> Death_stack; 
    175175 
    176         Particle_vector particles_; 
    177         Death_stack deadparts_; 
    178          
    179         osg::BoundingBox def_bbox_; 
    180          
    181         Alignment alignment_; 
    182         osg::Vec3 align_X_axis_; 
    183         osg::Vec3 align_Y_axis_; 
    184  
    185         bool doublepass_; 
    186         bool frozen_; 
    187  
    188         osg::Vec3 bmin_; 
    189         osg::Vec3 bmax_; 
    190  
    191         bool reset_bounds_flag_; 
    192         bool bounds_computed_; 
    193  
    194         Particle def_ptemp_; 
    195         mutable int last_frame_; 
    196         bool freeze_on_cull_; 
    197          
    198         int detail_; 
    199         mutable int draw_count_; 
     176        Particle_vector _particles; 
     177        Death_stack _deadparts; 
     178         
     179        osg::BoundingBox _def_bbox; 
     180         
     181        Alignment _alignment; 
     182        osg::Vec3 _align_X_axis; 
     183        osg::Vec3 _align_Y_axis; 
     184 
     185        bool _doublepass; 
     186        bool _frozen; 
     187 
     188        osg::Vec3 _bmin; 
     189        osg::Vec3 _bmax; 
     190 
     191        bool _reset_bounds_flag; 
     192        bool _bounds_computed; 
     193 
     194        Particle _def_ptemp; 
     195        mutable int _last_frame; 
     196        bool _freeze_on_cull; 
     197         
     198        int _detail; 
     199        mutable int _draw_count; 
    200200         
    201201    }; 
     
    205205    inline ParticleSystem::Alignment ParticleSystem::getParticleAlignment() const 
    206206    { 
    207         return alignment_; 
     207        return _alignment; 
    208208    } 
    209209     
    210210    inline void ParticleSystem::setParticleAlignment(Alignment a) 
    211211    { 
    212         alignment_ = a; 
    213     } 
    214      
    215     inline const osg::Vec3 &ParticleSystem::getAlignVectorX() const 
    216     { 
    217         return align_X_axis_; 
    218     } 
    219      
    220     inline void ParticleSystem::setAlignVectorX(const osg::Vec3 &v) 
    221     { 
    222         align_X_axis_ = v; 
    223     } 
    224  
    225     inline const osg::Vec3 &ParticleSystem::getAlignVectorY() const 
    226     { 
    227         return align_Y_axis_; 
    228     } 
    229      
    230     inline void ParticleSystem::setAlignVectorY(const osg::Vec3 &v) 
    231     { 
    232         align_Y_axis_ = v; 
    233     } 
    234      
    235     inline void ParticleSystem::setAlignVectors(const osg::Vec3 &X, const osg::Vec3 &Y) 
    236     { 
    237         align_X_axis_ = X; 
    238         align_Y_axis_ = Y; 
     212        _alignment = a; 
     213    } 
     214     
     215    inline const osg::Vec3& ParticleSystem::getAlignVectorX() const 
     216    { 
     217        return _align_X_axis; 
     218    } 
     219     
     220    inline void ParticleSystem::setAlignVectorX(const osg::Vec3& v) 
     221    { 
     222        _align_X_axis = v; 
     223    } 
     224 
     225    inline const osg::Vec3& ParticleSystem::getAlignVectorY() const 
     226    { 
     227        return _align_Y_axis; 
     228    } 
     229     
     230    inline void ParticleSystem::setAlignVectorY(const osg::Vec3& v) 
     231    { 
     232        _align_Y_axis = v; 
     233    } 
     234     
     235    inline void ParticleSystem::setAlignVectors(const osg::Vec3& X, const osg::Vec3& Y) 
     236    { 
     237        _align_X_axis = X; 
     238        _align_Y_axis = Y; 
    239239    } 
    240240 
    241241    inline bool ParticleSystem::isFrozen() const 
    242242    { 
    243         return frozen_; 
     243        return _frozen; 
    244244    } 
    245245     
    246246    inline void ParticleSystem::setFrozen(bool v) 
    247247    { 
    248         frozen_ = v; 
    249     } 
    250      
    251     inline const osg::BoundingBox &ParticleSystem::getDefaultBoundingBox() const 
    252     { 
    253         return def_bbox_; 
    254     } 
    255      
    256     inline void ParticleSystem::setDefaultBoundingBox(const osg::BoundingBox &bbox) 
    257     { 
    258         def_bbox_ = bbox; 
     248        _frozen = v; 
     249    } 
     250     
     251    inline const osg::BoundingBox& ParticleSystem::getDefaultBoundingBox() const 
     252    { 
     253        return _def_bbox; 
     254    } 
     255     
     256    inline void ParticleSystem::setDefaultBoundingBox(const osg::BoundingBox& bbox) 
     257    { 
     258        _def_bbox = bbox; 
    259259    } 
    260260 
    261261    inline bool ParticleSystem::getDoublePassRendering() const 
    262262    { 
    263         return doublepass_; 
     263        return _doublepass; 
    264264    } 
    265265 
    266266    inline void ParticleSystem::setDoublePassRendering(bool v) 
    267267    { 
    268         doublepass_ = v; 
     268        _doublepass = v; 
    269269    } 
    270270 
    271271    inline int ParticleSystem::numParticles() const 
    272272    { 
    273         return static_cast<int>(particles_.size()); 
     273        return static_cast<int>(_particles.size()); 
    274274    } 
    275275 
    276276    inline int ParticleSystem::numDeadParticles() const 
    277277    { 
    278         return static_cast<int>(deadparts_.size()); 
    279     } 
    280  
    281     inline Particle *ParticleSystem::getParticle(int i) 
    282     { 
    283         return &particles_[i]; 
    284     } 
    285  
    286     inline const Particle *ParticleSystem::getParticle(int i) const 
    287     { 
    288         return &particles_[i]; 
     278        return static_cast<int>(_deadparts.size()); 
     279    } 
     280 
     281    inline Particle* ParticleSystem::getParticle(int i) 
     282    { 
     283        return &_particles[i]; 
     284    } 
     285 
     286    inline const Particle* ParticleSystem::getParticle(int i) const 
     287    { 
     288        return &_particles[i]; 
    289289    } 
    290290 
    291291    inline void ParticleSystem::destroyParticle(int i) 
    292292    { 
    293         particles_[i].kill(); 
     293        _particles[i].kill(); 
    294294    } 
    295295     
    296296    inline int ParticleSystem::getLastFrameNumber() const 
    297297    { 
    298         return last_frame_; 
     298        return _last_frame; 
    299299    } 
    300300 
    301301    inline bool ParticleSystem::computeBound() const 
    302302    {         
    303         if (!bounds_computed_) { 
    304             _bbox = def_bbox_; 
     303        if (!_bounds_computed) { 
     304            _bbox = _def_bbox; 
    305305        } else { 
    306                         _bbox._min = bmin_; 
    307                         _bbox._max = bmax_; 
     306                        _bbox._min = _bmin; 
     307                        _bbox._max = _bmax; 
    308308        } 
    309309        _bbox_computed = true; 
     
    311311    } 
    312312 
    313     inline void ParticleSystem::update_bounds(const osg::Vec3 &p, float r) 
    314     { 
    315         if (reset_bounds_flag_) { 
    316             reset_bounds_flag_ = false; 
    317             bmin_ = p; 
    318             bmax_ = p; 
     313    inline void ParticleSystem::update_bounds(const osg::Vec3& p, float r) 
     314    { 
     315        if (_reset_bounds_flag) { 
     316            _reset_bounds_flag = false; 
     317            _bmin = p; 
     318            _bmax = p; 
    319319        } else { 
    320             if (p.x() - r < bmin_.x()) bmin_.x() = p.x() - r; 
    321             if (p.y() - r < bmin_.y()) bmin_.y() = p.y() - r; 
    322             if (p.z() - r < bmin_.z()) bmin_.z() = p.z() - r; 
    323             if (p.x() + r > bmax_.x()) bmax_.x() = p.x() + r; 
    324             if (p.y() + r > bmax_.y()) bmax_.y() = p.y() + r; 
    325             if (p.z() + r > bmax_.z()) bmax_.z() = p.z() + r; 
     320            if (p.x() - r < _bmin.x()) _bmin.x() = p.x() - r; 
     321            if (p.y() - r < _bmin.y()) _bmin.y() = p.y() - r; 
     322            if (p.z() - r < _bmin.z()) _bmin.z() = p.z() - r; 
     323            if (p.x() + r > _bmax.x()) _bmax.x() = p.x() + r; 
     324            if (p.y() + r > _bmax.y()) _bmax.y() = p.y() + r; 
     325            if (p.z() + r > _bmax.z()) _bmax.z() = p.z() + r; 
    326326             
    327             if (!bounds_computed_)  
    328                 bounds_computed_ = true; 
     327            if (!_bounds_computed)  
     328                _bounds_computed = true; 
    329329        } 
    330330    } 
    331331 
    332     inline Particle &ParticleSystem::getDefaultParticleTemplate() 
    333     { 
    334         return def_ptemp_; 
    335     } 
    336  
    337     inline const Particle &ParticleSystem::getDefaultParticleTemplate() const 
    338     { 
    339         return def_ptemp_; 
    340     } 
    341  
    342     inline void ParticleSystem::setDefaultParticleTemplate(const Particle &p) 
    343     { 
    344         def_ptemp_ = p; 
     332    inline Particle& ParticleSystem::getDefaultParticleTemplate() 
     333    { 
     334        return _def_ptemp; 
     335    } 
     336 
     337    inline const Particle& ParticleSystem::getDefaultParticleTemplate() const 
     338    { 
     339        return _def_ptemp; 
     340    } 
     341 
     342    inline void ParticleSystem::setDefaultParticleTemplate(const Particle& p) 
     343    { 
     344        _def_ptemp = p; 
    345345    } 
    346346     
    347347    inline bool ParticleSystem::getFreezeOnCull() const 
    348348    { 
    349         return freeze_on_cull_; 
     349        return _freeze_on_cull; 
    350350    } 
    351351     
    352352    inline void ParticleSystem::setFreezeOnCull(bool v) 
    353353    { 
    354         freeze_on_cull_ = v; 
     354        _freeze_on_cull = v; 
    355355    } 
    356356     
    357357    inline int ParticleSystem::getLevelOfDetail() const 
    358358    { 
    359         return detail_; 
     359        return _detail; 
    360360    } 
    361361     
     
    363363    { 
    364364        if (v < 1) v = 1; 
    365         detail_ = v; 
     365        _detail = v; 
    366366    } 
    367367     
    368368    // I'm not sure this function should be inlined...  
    369369     
    370     inline Particle *ParticleSystem::createParticle(const Particle *ptemplate) 
     370    inline Particle* ParticleSystem::createParticle(const Particle* ptemplate) 
    371371    { 
    372372        // is there any dead particle? 
    373         if (!deadparts_.empty()) { 
     373        if (!_deadparts.empty()) { 
    374374 
    375375            // retrieve a pointer to the last dead particle 
    376             Particle *P = deadparts_.top(); 
     376            Particle* P = _deadparts.top(); 
    377377 
    378378            // create a new (alive) particle in the same place 
    379             *P = Particle(ptemplate? *ptemplate: def_ptemp_); 
     379            *P = Particle(ptemplate? *ptemplate: _def_ptemp); 
    380380 
    381381            // remove the pointer from the death stack 
    382             deadparts_.pop(); 
     382            _deadparts.pop(); 
    383383            return P; 
    384384 
     
    386386 
    387387            // add a new particle to the vector 
    388             particles_.push_back(Particle(ptemplate? *ptemplate: def_ptemp_)); 
    389             return &particles_.back(); 
     388            _particles.push_back(Particle(ptemplate? *ptemplate: _def_ptemp)); 
     389            return &_particles.back(); 
    390390        } 
    391391    } 
  • OpenSceneGraph/trunk/include/osgParticle/ParticleSystemUpdater

    r4038 r4121  
    1313//osgParticle - Copyright (C) 2002 Marco Jez 
    1414 
    15 #ifndef OSGPARTICLE_PARTICLESYSTEMUPDATER_ 
    16 #define OSGPARTICLE_PARTICLESYSTEMUPDATER_ 1 
     15#ifndef OSGPARTICLE_PARTICLESYSTEMUPDATER 
     16#define OSGPARTICLE_PARTICLESYSTEMUPDATER 1 
    1717 
    1818#include <osgParticle/Export> 
     
    4040    public: 
    4141        ParticleSystemUpdater(); 
    42         ParticleSystemUpdater(const ParticleSystemUpdater &copy, const osg::CopyOp &copyop = osg::CopyOp::SHALLOW_COPY); 
     42        ParticleSystemUpdater(const ParticleSystemUpdater& copy, const osg::CopyOp& copyop = osg::CopyOp::SHALLOW_COPY); 
    4343         
    4444        META_Node(osgParticle,ParticleSystemUpdater); 
    4545         
    4646        /// Add a particle system to the list. 
    47         inline bool addParticleSystem(ParticleSystem *ps); 
     47        inline bool addParticleSystem(ParticleSystem* ps); 
    4848 
    4949        /// Remove a particle system from the list (by pointer). 
    50         inline bool removeParticleSystem(ParticleSystem *ps); 
     50        inline bool removeParticleSystem(ParticleSystem* ps); 
    5151 
    5252        /// Remove a particle system(s) from the list (by index). 
     
    5454         
    5555        /// Replace ParticleSystem with another ParticleSystem. 
    56         inline bool replaceParticleSystem(ParticleSystem *origPS, ParticleSystem *newPS); 
     56        inline bool replaceParticleSystem(ParticleSystem* origPS, ParticleSystem* newPS); 
    5757 
    5858        /// set a particle system by index. 
     
    7474        inline unsigned int getParticleSystemIndex( const ParticleSystem* ps ) const; 
    7575         
    76         virtual void traverse(osg::NodeVisitor &nv); 
     76        virtual void traverse(osg::NodeVisitor& nv); 
    7777         
    7878    protected: 
     
    8585        typedef std::vector<osg::ref_ptr<ParticleSystem> > ParticleSystem_Vector; 
    8686         
    87         ParticleSystem_Vector psv_; 
    88         double t0_; 
     87        ParticleSystem_Vector _psv; 
     88        double _t0; 
    8989    }; 
    9090     
     
    9898    } 
    9999     
    100     inline bool ParticleSystemUpdater::addParticleSystem(ParticleSystem *ps) 
     100    inline bool ParticleSystemUpdater::addParticleSystem(ParticleSystem* ps) 
    101101    { 
    102         psv_.push_back(ps); 
     102        _psv.push_back(ps); 
    103103        return true; 
    104104    } 
    105105     
    106     inline bool ParticleSystemUpdater::removeParticleSystem(ParticleSystem *ps) 
     106    inline bool ParticleSystemUpdater::removeParticleSystem(ParticleSystem* ps) 
    107107    { 
    108108       unsigned int i = getParticleSystemIndex( ps ); 
    109        if( i >= psv_.size() ) return false; 
     109       if( i >= _psv.size() ) return false; 
    110110       removeParticleSystem( i ); 
    111111        return true; 
     
    114114    inline bool ParticleSystemUpdater::removeParticleSystem(unsigned int pos, unsigned int numParticleSystemsToRemove) 
    115115    { 
    116        if( (pos < psv_.size()) && (numParticleSystemsToRemove > 0) ) 
     116       if( (pos < _psv.size()) && (numParticleSystemsToRemove > 0) ) 
    117117       { 
    118118          unsigned int endOfRemoveRange = pos + numParticleSystemsToRemove; 
    119           if( endOfRemoveRange > psv_.size() ) 
     119          if( endOfRemoveRange > _psv.size() ) 
    120120          { 
    121121             osg::notify(osg::DEBUG_INFO)<<"Warning: ParticleSystem::removeParticleSystem(i,numParticleSystemsToRemove) has been passed an excessive number"<<std::endl; 
    122122             osg::notify(osg::DEBUG_INFO)<<"         of ParticleSystems to remove, trimming just to end of ParticleSystem list."<<std::endl; 
    123              endOfRemoveRange = psv_.size(); 
     123             endOfRemoveRange = _psv.size(); 
    124124          } 
    125           psv_.erase(psv_.begin()+pos, psv_.begin()+endOfRemoveRange); 
     125          _psv.erase(_psv.begin()+pos, _psv.begin()+endOfRemoveRange); 
    126126          return true; 
    127127       } 
     
    129129    } 
    130130 
    131     inline bool ParticleSystemUpdater::replaceParticleSystem( ParticleSystem *origPS, ParticleSystem* newPS ) 
     131    inline bool ParticleSystemUpdater::replaceParticleSystem( ParticleSystem* origPS, ParticleSystem* newPS ) 
    132132    { 
    133133       if( (newPS == NULL) || (origPS == newPS) ) return false; 
    134134 
    135135       unsigned int pos = getParticleSystemIndex( origPS ); 
    136        if( pos < psv_.size() ) 
     136       if( pos < _psv.size() ) 
    137137       { 
    138138          return setParticleSystem( pos, newPS ); 
     
    143143    inline bool ParticleSystemUpdater::setParticleSystem( unsigned int i, ParticleSystem* ps ) 
    144144    { 
    145        if( (i < psv_.size()) && ps ) 
     145       if( (i < _psv.size()) && ps ) 
    146146       { 
    147           psv_[i] = ps; 
     147          _psv[i] = ps; 
    148148          return true; 
    149149       } 
     
    153153    inline unsigned int ParticleSystemUpdater::getNumParticleSystems() const 
    154154    { 
    155         return static_cast<int>(psv_.size()); 
     155        return static_cast<int>(_psv.size()); 
    156156    } 
    157157     
    158158    inline ParticleSystem* ParticleSystemUpdater::getParticleSystem(unsigned int i) 
    159159    { 
    160         return psv_[i].get(); 
     160        return _psv[i].get(); 
    161161    } 
    162162 
    163163    inline const ParticleSystem* ParticleSystemUpdater::getParticleSystem(unsigned int i) const 
    164164    { 
    165         return psv_[i].get(); 
     165        return _psv[i].get(); 
    166166    } 
    167167 
    168168    inline bool ParticleSystemUpdater::containsParticleSystem( const ParticleSystem* ps ) const 
    169169    { 
    170        for( ParticleSystem_Vector::const_iterator itr=psv_.begin(); 
    171             itr!=psv_.end(); 
     170       for( ParticleSystem_Vector::const_iterator itr=_psv.begin(); 
     171            itr!=_psv.end(); 
    172172            ++itr ) 
    173173       { 
     
    179179    inline unsigned int ParticleSystemUpdater::getParticleSystemIndex( const ParticleSystem* ps ) const 
    180180    { 
    181        for( unsigned int particleSystemNum=0; particleSystemNum<psv_.size(); ++particleSystemNum ) 
     181       for( unsigned int particleSystemNum=0; particleSystemNum<_psv.size(); ++particleSystemNum ) 
    182182       { 
    183           if( psv_[particleSystemNum] == ps ) return particleSystemNum; 
     183          if( _psv[particleSystemNum] == ps ) return particleSystemNum; 
    184184       } 
    185        return psv_.size(); // node not found. 
     185       return _psv.size(); // node not found. 
    186186    } 
    187187 
  • OpenSceneGraph/trunk/include/osgParticle/Placer

    r4038 r4121  
    1313//osgParticle - Copyright (C) 2002 Marco Jez 
    1414 
    15 #ifndef OSGPARTICLE_PLACER_ 
    16 #define OSGPARTICLE_PLACER_ 1 
     15#ifndef OSGPARTICLE_PLACER 
     16#define OSGPARTICLE_PLACER 1 
    1717 
    1818#include <osg/CopyOp> 
     
    3131    public: 
    3232        inline Placer(); 
    33         inline Placer(const Placer &copy, const osg::CopyOp &copyop = osg::CopyOp::SHALLOW_COPY); 
     33        inline Placer(const Placer& copy, const osg::CopyOp& copyop = osg::CopyOp::SHALLOW_COPY); 
    3434 
    35         virtual const char *libraryName() const { return "osgParticle"; } 
    36         virtual const char *className() const { return "Placer"; } 
    37         virtual bool isSameKindAs(const osg::Object *obj) const { return dynamic_cast<const Placer *>(obj) != 0; } 
     35        virtual const char* libraryName() const { return "osgParticle"; } 
     36        virtual const char* className() const { return "Placer"; } 
     37        virtual bool isSameKindAs(const osg::Object* obj) const { return dynamic_cast<const Placer *>(obj) != 0; } 
    3838 
    3939        /// Place a particle. Must be implemented in descendant classes. 
    40         virtual void place(Particle *P) const = 0; 
     40        virtual void place(Particle* P) const = 0; 
    4141 
    4242    protected: 
    4343        ~Placer() {} 
    44         Placer &operator=(const Placer &) { return *this; } 
     44        Placer& operator=(const Placer& ) { return *this; } 
    4545    }; 
    4646     
     
    5252    } 
    5353     
    54     inline Placer::Placer(const Placer &copy, const osg::CopyOp &copyop) 
     54    inline Placer::Placer(const Placer& copy, const osg::CopyOp& copyop) 
    5555    : osg::Object(copy, copyop) 
    5656    { 
  • OpenSceneGraph/trunk/include/osgParticle/PointPlacer

    r4038 r4121  
    1313//osgParticle - Copyright (C) 2002 Marco Jez 
    1414 
    15 #ifndef OSGPARTICLE_POINTPLACER_ 
    16 #define OSGPARTICLE_POINTPLACER_ 1 
     15#ifndef OSGPARTICLE_POINT_PLACER 
     16#define OSGPARTICLE_POINT_PLACER 1 
    1717 
    1818#include <osgParticle/CenteredPlacer> 
     
    3232    public: 
    3333        inline PointPlacer(); 
    34         inline PointPlacer(const PointPlacer &copy, const osg::CopyOp &copyop = osg::CopyOp::SHALLOW_COPY); 
     34        inline PointPlacer(const PointPlacer& copy, const osg::CopyOp& copyop = osg::CopyOp::SHALLOW_COPY); 
    3535 
    3636        META_Object(osgParticle, PointPlacer); 
     
    4040            manually. 
    4141        */ 
    42         inline void place(Particle *P) const; 
     42        inline void place(Particle* P) const; 
    4343 
    4444    protected: 
    4545        virtual ~PointPlacer() {} 
    46         PointPlacer &operator=(const PointPlacer &) { return *this; }         
     46        PointPlacer& operator=(const PointPlacer&) { return *this; }         
    4747    }; 
    4848 
     
    5454    } 
    5555     
    56     inline PointPlacer::PointPlacer(const PointPlacer &copy, const osg::CopyOp &copyop) 
     56    inline PointPlacer::PointPlacer(const PointPlacer& copy, const osg::CopyOp& copyop) 
    5757    : CenteredPlacer(copy, copyop) 
    5858    { 
    5959    } 
    6060 
    61     inline void PointPlacer::place(Particle *P) const 
     61    inline void PointPlacer::place(Particle* P) const 
    6262    { 
    6363        P->setPosition(getCenter()); 
  • OpenSceneGraph/trunk/include/osgParticle/Program

    r4038 r4121  
    1313//osgParticle - Copyright (C) 2002 Marco Jez 
    1414 
    15 #ifndef OSGPARTICLE_PROGRAM_ 
    16 #define OSGPARTICLE_PROGRAM_ 1 
     15#ifndef OSGPARTICLE_PROGRAM 
     16#define OSGPARTICLE_PROGRAM 1 
    1717 
    1818#include <osgParticle/Export> 
     
    3333        (usually updating their velocity vector). 
    3434    */ 
    35     class OSGPARTICLE_EXPORT Program: public ParticleProcessor { 
     35    class OSGPARTICLE_EXPORT Program: public ParticleProcessor 
     36    { 
    3637    public: 
    3738        Program(); 
    38         Program(const Program &copy, const osg::CopyOp &copyop = osg::CopyOp::SHALLOW_COPY); 
     39        Program(const Program& copy, const osg::CopyOp& copyop = osg::CopyOp::SHALLOW_COPY); 
    3940 
    40         virtual const char *libraryName() const { return "osgParticle"; } 
    41         virtual const char *className() const { return "Program"; } 
    42         virtual bool isSameKindAs(const osg::Object *obj) const { return dynamic_cast<const Program*>(obj) != 0; } 
     41        virtual const char* libraryName() const { return "osgParticle"; } 
     42        virtual const char* className() const { return "Program"; } 
     43        virtual bool isSameKindAs(const osg::Object* obj) const { return dynamic_cast<const Program*>(obj) != 0; } 
    4344        virtual void accept(osg::NodeVisitor& nv) { if (nv.validNodeMask(*this)) { nv.pushOntoNodePath(this); nv.apply(*this); nv.popFromNodePath(); } } 
    4445 
    4546    protected: 
    4647        virtual ~Program() {} 
    47         Program &operator=(const Program &) { return *this; } 
     48        Program& operator=(const Program&) { return *this; } 
    4849 
    4950        /// Implementation of <CODE>ParticleProcessor::process()</CODE>. Do not call this method by yourself. 
  • OpenSceneGraph/trunk/include/osgParticle/RadialShooter

    r4038 r4121  
    1313//osgParticle - Copyright (C) 2002 Marco Jez 
    1414 
    15 #ifndef OSGPARTICLE_RADIALSHOOTER_ 
    16 #define OSGPARTICLE_RADIALSHOOTER_ 1 
     15#ifndef OSGPARTICLE_RADIAL_SHOOTER 
     16#define OSGPARTICLE_RADIAL_SHOOTER 1 
    1717 
    1818#include <osgParticle/Shooter> 
     
    3737    public: 
    3838        inline RadialShooter(); 
    39         inline RadialShooter(const RadialShooter &copy, const osg::CopyOp &copyop = osg::CopyOp::SHALLOW_COPY); 
     39        inline RadialShooter(const RadialShooter& copy, const osg::CopyOp& copyop = osg::CopyOp::SHALLOW_COPY); 
    4040 
    4141        META_Object(osgParticle, RadialShooter); 
    4242 
    4343        /// Get the range of possible values for <B>theta</B> angle. 
    44         inline const rangef &getThetaRange() const; 
     44        inline const rangef& getThetaRange() const; 
    4545         
    4646        /// Set the range of possible values for <B>theta</B> angle. 
    47         inline void setThetaRange(const rangef &r); 
     47        inline void setThetaRange(const rangef& r); 
    4848         
    4949        /// Set the range of possible values for <B>theta</B> angle. 
     
    5151         
    5252        /// Get the range of possible values for <B>phi</B> angle. 
    53         inline const rangef &getPhiRange() const; 
     53        inline const rangef& getPhiRange() const; 
    5454         
    5555        /// Set the range of possible values for <B>phi</B> angle. 
    56         inline void setPhiRange(const rangef &r); 
     56        inline void setPhiRange(const rangef& r); 
    5757         
    5858        /// Set the range of possible values for <B>phi</B> angle. 
     
    6060         
    6161        /// Get the range of possible values for initial speed of particles. 
    62         inline const rangef &getInitialSpeedRange() const;         
     62        inline const rangef& getInitialSpeedRange() const;         
    6363         
    6464        /// Set the range of possible values for initial speed of particles. 
    65         inline void setInitialSpeedRange(const rangef &r); 
     65        inline void setInitialSpeedRange(const rangef& r); 
    6666         
    6767        /// Set the range of possible values for initial speed of particles. 
     
    6969 
    7070        /// Get the range of possible values for initial rotational speed of particles. 
    71         inline const rangev3 &getInitialRotationalSpeedRange() const;         
     71        inline const rangev3& getInitialRotationalSpeedRange() const;         
    7272         
    7373        /// Set the range of possible values for initial rotational speed of particles. 
    74         inline void setInitialRotationalSpeedRange(const rangev3 &r); 
     74        inline void setInitialRotationalSpeedRange(const rangev3& r); 
    7575         
    7676        /// Set the range of possible values for initial rotational speed of particles. 
    77         inline void setInitialRotationalSpeedRange(const osg::Vec3 &r1, const osg::Vec3 &r2); 
     77        inline void setInitialRotationalSpeedRange(const osg::Vec3& r1, const osg::Vec3& r2); 
    7878 
    7979        /// Shoot a particle. Do not call this method manually. 
    80         inline void shoot(Particle *P) const; 
     80        inline void shoot(Particle* P) const; 
    8181 
    8282    protected: 
    8383        virtual ~RadialShooter() {} 
    84         RadialShooter &operator=(const RadialShooter &) { return *this; } 
     84        RadialShooter& operator=(const RadialShooter&) { return *this; } 
    8585 
    8686    private: 
    87         rangef theta_range_; 
    88         rangef phi_range_; 
    89         rangef speed_range_; 
    90         rangev3 rot_speed_range_; 
     87        rangef _theta_range; 
     88        rangef _phi_range; 
     89        rangef _speed_range; 
     90        rangev3 _rot_speed_range; 
    9191    }; 
    9292 
     
    9595    inline RadialShooter::RadialShooter() 
    9696    :    Shooter(),  
    97         theta_range_(0, 0.5f*osg::PI_4),  
    98         phi_range_(0, 2*osg::PI),  
    99         speed_range_(10, 10), 
    100         rot_speed_range_(osg::Vec3(0,0,0), osg::Vec3(0,0,0)) 
     97        _theta_range(0, 0.5f*osg::PI_4),  
     98        _phi_range(0, 2*osg::PI),  
     99        _speed_range(10, 10), 
     100        _rot_speed_range(osg::Vec3(0,0,0), osg::Vec3(0,0,0)) 
    101101    { 
    102102    } 
    103103 
    104     inline RadialShooter::RadialShooter(const RadialShooter &copy, const osg::CopyOp &copyop) 
     104    inline RadialShooter::RadialShooter(const RadialShooter& copy, const osg::CopyOp& copyop) 
    105105    :    Shooter(copy, copyop),  
    106         theta_range_(copy.theta_range_),  
    107         phi_range_(copy.phi_range_),  
    108         speed_range_(copy.speed_range_), 
    109         rot_speed_range_(copy.rot_speed_range_) 
     106        _theta_range(copy._theta_range),  
     107        _phi_range(copy._phi_range),  
     108        _speed_range(copy._speed_range), 
     109        _rot_speed_range(copy._rot_speed_range) 
    110110    { 
    111111    } 
    112112     
    113     inline const rangef &RadialShooter::getThetaRange() const 
     113    inline const rangef& RadialShooter::getThetaRange() const 
    114114    { 
    115         return theta_range_; 
     115        return _theta_range; 
    116116    } 
    117117 
    118     inline const rangef &RadialShooter::getPhiRange() const 
     118    inline const rangef& RadialShooter::getPhiRange() const 
    119119    { 
    120         return phi_range_; 
     120        return _phi_range; 
    121121    } 
    122122 
    123     inline const rangef &RadialShooter::getInitialSpeedRange() const 
     123    inline const rangef& RadialShooter::getInitialSpeedRange() const 
    124124    { 
    125         return speed_range_; 
     125        return _speed_range; 
    126126    } 
    127127 
    128     inline const rangev3 &RadialShooter::getInitialRotationalSpeedRange() const 
     128    inline const rangev3& RadialShooter::getInitialRotationalSpeedRange() const 
    129129    { 
    130         return rot_speed_range_; 
     130        return _rot_speed_range; 
    131131    } 
    132132 
    133     inline void RadialShooter::setThetaRange(const rangef &r) 
     133    inline void RadialShooter::setThetaRange(const rangef& r) 
    134134    { 
    135         theta_range_ = r; 
     135        _theta_range = r; 
    136136    } 
    137137 
    138138    inline void RadialShooter::setThetaRange(float r1, float r2) 
    139139    { 
    140         theta_range_.minimum = r1; 
    141         theta_range_.maximum = r2; 
     140        _theta_range.minimum = r1; 
     141        _theta_range.maximum = r2; 
    142142    } 
    143143 
    144     inline void RadialShooter::setPhiRange(const rangef &r) 
     144    inline void RadialShooter::setPhiRange(const rangef& r) 
    145145    { 
    146         phi_range_ = r; 
     146        _phi_range = r; 
    147147    } 
    148148 
    149149    inline void RadialShooter::setPhiRange(float r1, float r2) 
    150150    { 
    151         phi_range_.minimum = r1; 
    152         phi_range_.maximum = r2; 
     151        _phi_range.minimum = r1; 
     152        _phi_range.maximum = r2; 
    153153    } 
    154154 
    155     inline void RadialShooter::setInitialSpeedRange(const rangef &r) 
     155    inline void RadialShooter::setInitialSpeedRange(const rangef& r) 
    156156    { 
    157         speed_range_ = r; 
     157        _speed_range = r; 
    158158    } 
    159159 
    160160    inline void RadialShooter::setInitialSpeedRange(float r1, float r2) 
    161161    { 
    162         speed_range_.minimum = r1; 
    163         speed_range_.maximum = r2; 
     162        _speed_range.minimum = r1; 
     163        _speed_range.maximum = r2; 
    164164    } 
    165165 
    166     inline void RadialShooter::setInitialRotationalSpeedRange(const rangev3 &r) 
     166    inline void RadialShooter::setInitialRotationalSpeedRange(const rangev3& r) 
    167167    { 
    168         rot_speed_range_ = r; 
     168        _rot_speed_range = r; 
    169169    } 
    170170 
    171     inline void RadialShooter::setInitialRotationalSpeedRange(const osg::Vec3 &r1, const osg::Vec3 &r2) 
     171    inline void RadialShooter::setInitialRotationalSpeedRange(const osg::Vec3& r1, const osg::Vec3& r2) 
    172172    { 
    173         rot_speed_range_.minimum = r1; 
    174         rot_speed_range_.maximum = r2; 
     173        _rot_speed_range.minimum = r1; 
     174        _rot_speed_range.maximum = r2; 
    175175    } 
    176176 
    177     inline void RadialShooter::shoot(Particle *P) const 
     177    inline void RadialShooter::shoot(Particle* P) const 
    178178    { 
    179         float theta = theta_range_.get_random(); 
    180         float phi = phi_range_.get_random(); 
    181         float speed = speed_range_.get_random(); 
    182         osg::Vec3 rot_speed = rot_speed_range_.get_random(); 
     179        float theta = _theta_range.get_random(); 
     180        float phi = _phi_range.get_random(); 
     181        float speed = _speed_range.get_random(); 
     182        osg::Vec3 rot_speed = _rot_speed_range.get_random(); 
    183183         
    184184        P->setVelocity(osg::Vec3( 
  • OpenSceneGraph/trunk/include/osgParticle/RandomRateCounter

    r4038 r4121  
    1313//osgParticle - Copyright (C) 2002 Marco Jez 
    1414 
    15 #ifndef OSGPARTICLE_RANDOMRATECOUNTER_ 
    16 #define OSGPARTICLE_RANDOMRATECOUNTER_ 1 
     15#ifndef OSGPARTICLE_RANDOMRATE_COUNTER 
     16#define OSGPARTICLE_RANDOMRATE_COUNTER 1 
    1717 
    1818#include <osgParticle/VariableRateCounter> 
     
    2727    public: 
    2828        inline RandomRateCounter(); 
    29         inline RandomRateCounter(const RandomRateCounter &copy, const osg::CopyOp &copyop = osg::CopyOp::SHALLOW_COPY); 
     29        inline RandomRateCounter(const RandomRateCounter& copy, const osg::CopyOp& copyop = osg::CopyOp::SHALLOW_COPY); 
    3030         
    3131        META_Object(osgParticle, RandomRateCounter); 
     
    3737        virtual ~RandomRateCounter() {} 
    3838         
    39         mutable float np_; 
     39        mutable float _np; 
    4040    }; 
    4141     
     
    4343     
    4444    inline RandomRateCounter::RandomRateCounter() 
    45     : VariableRateCounter(), np_(0) 
     45    : VariableRateCounter(), _np(0) 
    4646    { 
    4747    } 
    4848     
    49     inline RandomRateCounter::RandomRateCounter(const RandomRateCounter &copy, const osg::CopyOp &copyop) 
    50     : VariableRateCounter(copy, copyop), np_(copy.np_) 
     49    inline RandomRateCounter::RandomRateCounter(const RandomRateCounter& copy, const osg::CopyOp& copyop) 
     50    : VariableRateCounter(copy, copyop), _np(copy._np) 
    5151    { 
    5252    } 
     
    5454    inline int RandomRateCounter::numParticlesToCreate(double dt) const 
    5555    { 
    56         np_ += dt * getRateRange().get_random(); 
    57         int n = static_cast<int>(np_); 
    58         np_ -= n; 
     56        _np += dt * getRateRange().get_random(); 
     57        int n = static_cast<int>(_np); 
     58        _np -= n; 
    5959        return n; 
    6060    }     
  • OpenSceneGraph/trunk/include/osgParticle/SectorPlacer

    r4038 r4121  
    1313//osgParticle - Copyright (C) 2002 Marco Jez 
    1414 
    15 #ifndef OSGPARTICLE_SECTORPLACER_ 
    16 #define OSGPARTICLE_SECTORPLACER_ 1 
     15#ifndef OSGPARTICLE_SECTOR_PLACER 
     16#define OSGPARTICLE_SECTOR_PLACER 1 
    1717 
    1818#include <osgParticle/CenteredPlacer> 
     
    3737    public: 
    3838        inline SectorPlacer(); 
    39         inline SectorPlacer(const SectorPlacer &copy, const osg::CopyOp &copyop = osg::CopyOp::SHALLOW_COPY); 
     39        inline SectorPlacer(const SectorPlacer& copy, const osg::CopyOp& copyop = osg::CopyOp::SHALLOW_COPY); 
    4040         
    4141        /// Get the range of possible values for radius. 
    42         inline const rangef &getRadiusRange() const; 
     42        inline const rangef& getRadiusRange() const; 
    4343         
    4444        /// Set the range of possible values for radius. 
    45         inline void setRadiusRange(const rangef &r); 
     45        inline void setRadiusRange(const rangef& r); 
    4646         
    4747        /// Set the range of possible values for radius. 
     
    4949         
    5050        /// Get the range of possible values for the central angle. 
    51         inline const rangef &getPhiRange() const;         
     51        inline const rangef& getPhiRange() const;         
    5252         
    5353        /// Set the range of possible values for the central angle. 
    54         inline void setPhiRange(const rangef &r); 
     54        inline void setPhiRange(const rangef& r); 
    5555         
    5656        /// Set the range of possible values for the central angle. 
     
    6060         
    6161        /// Place a particle. Do not call it manually. 
    62         inline void place(Particle *P) const; 
     62        inline void place(Particle* P) const; 
    6363 
    6464    protected: 
    6565        virtual ~SectorPlacer() {} 
    66         SectorPlacer &operator=(const SectorPlacer &) { return *this; }         
     66        SectorPlacer& operator=(const SectorPlacer&) { return *this; }         
    6767         
    6868    private: 
    69         rangef rad_range_; 
    70         rangef phi_range_; 
     69        rangef _rad_range; 
     70        rangef _phi_range; 
    7171    }; 
    7272 
     
    7474     
    7575    inline SectorPlacer::SectorPlacer() 
    76     : CenteredPlacer(), rad_range_(0, 1), phi_range_(0, osg::PI*2) 
     76    : CenteredPlacer(), _rad_range(0, 1), _phi_range(0, osg::PI*2) 
    7777    { 
    7878    } 
    7979     
    80     inline SectorPlacer::SectorPlacer(const SectorPlacer &copy, const osg::CopyOp &copyop) 
    81     : CenteredPlacer(copy, copyop), rad_range_(copy.rad_range_), phi_range_(copy.phi_range_) 
     80    inline SectorPlacer::SectorPlacer(const SectorPlacer& copy, const osg::CopyOp& copyop) 
     81    : CenteredPlacer(copy, copyop), _rad_range(copy._rad_range), _phi_range(copy._phi_range) 
    8282    { 
    8383    } 
    8484     
    85     inline const rangef &SectorPlacer::getRadiusRange() const 
     85    inline const rangef& SectorPlacer::getRadiusRange() const 
    8686    { 
    87         return rad_range_; 
     87        return _rad_range; 
    8888    } 
    8989 
    90     inline const rangef &SectorPlacer::getPhiRange() const 
     90    inline const rangef& SectorPlacer::getPhiRange() const 
    9191    { 
    92         return phi_range_; 
     92        return _phi_range; 
    9393    } 
    9494 
    95     inline void SectorPlacer::setRadiusRange(const rangef &r) 
     95    inline void SectorPlacer::setRadiusRange(const rangef& r) 
    9696    { 
    97         rad_range_ = r; 
     97        _rad_range = r; 
    9898    } 
    9999     
    100100    inline void SectorPlacer::setRadiusRange(float r1, float r2) 
    101101    { 
    102         rad_range_.minimum = r1; 
    103         rad_range_.maximum = r2; 
     102        _rad_range.minimum = r1; 
     103        _rad_range.maximum = r2; 
    104104    } 
    105105     
    106     inline void SectorPlacer::setPhiRange(const rangef &r) 
     106    inline void SectorPlacer::setPhiRange(const rangef& r) 
    107107    { 
    108         phi_range_ = r; 
     108        _phi_range = r; 
    109109    } 
    110110     
    111111    inline void SectorPlacer::setPhiRange(float r1, float r2) 
    112112    { 
    113         phi_range_.minimum = r1; 
    114         phi_range_.maximum = r2; 
     113        _phi_range.minimum = r1; 
     114        _phi_range.maximum = r2; 
    115115    } 
    116116 
    117     inline void SectorPlacer::place(Particle *P) const 
     117    inline void SectorPlacer::place(Particle* P) const 
    118118    { 
    119         float rad = rad_range_.get_random_sqrtf(); 
    120         float phi = phi_range_.get_random(); 
     119        float rad = _rad_range.get_random_sqrtf(); 
     120        float phi = _phi_range.get_random(); 
    121121         
    122122        osg::Vec3 pos( 
  • OpenSceneGraph/trunk/include/osgParticle/SegmentPlacer

    r4038 r4121  
    1313//osgParticle - Copyright (C) 2002 Marco Jez 
    1414 
    15 #ifndef OSGPARTICLE_SEGMENTPLACER_ 
    16 #define OSGPARTICLE_SEGMENTPLACER_ 1 
     15#ifndef OSGPARTICLE_SEGMENT_PLACER 
     16#define OSGPARTICLE_SEGMENT_PLACER 1 
    1717 
    1818#include <osgParticle/Placer> 
     
    3333    public: 
    3434        inline SegmentPlacer(); 
    35         inline SegmentPlacer(const SegmentPlacer &copy, const osg::CopyOp &copyop = osg::CopyOp::SHALLOW_COPY); 
     35        inline SegmentPlacer(const SegmentPlacer& copy, const osg::CopyOp& copyop = osg::CopyOp::SHALLOW_COPY); 
    3636 
    3737        META_Object(osgParticle, SegmentPlacer); 
    3838 
    3939        /// get vertex <B>A</B>. 
    40         inline const osg::Vec3 &getVertexA() const; 
     40        inline const osg::Vec3& getVertexA() const; 
    4141         
    4242        /// Set vertex <B>A</B> of the segment as a vector. 
    43         inline void setVertexA(const osg::Vec3 &v); 
     43        inline void setVertexA(const osg::Vec3& v); 
    4444         
    4545        /// Set vertex <B>A</B> of the segment as three floats. 
     
    4747         
    4848        /// get vertex <B>B</B>. 
    49         inline const osg::Vec3 &getVertexB() const; 
     49        inline const osg::Vec3& getVertexB() const; 
    5050         
    5151        /// Set vertex <B>B</B> of the segment as a vector. 
    52         inline void setVertexB(const osg::Vec3 &v); 
     52        inline void setVertexB(const osg::Vec3& v); 
    5353         
    5454        /// Set vertex <B>B</B> of the segment as three floats. 
     
    5656         
    5757        /// Set both vertices. 
    58         inline void setSegment(const osg::Vec3 &A, const osg::Vec3 &B); 
     58        inline void setSegment(const osg::Vec3& A, const osg::Vec3& B); 
    5959         
    6060        /// Place a particle. This method is called by <CODE>ModularEmitter</CODE>, do not call it manually. 
    61         inline void place(Particle *P) const; 
     61        inline void place(Particle* P) const; 
    6262 
    6363    protected: 
    6464        virtual ~SegmentPlacer() {} 
    65         SegmentPlacer &operator=(const SegmentPlacer &) { return *this; }         
     65        SegmentPlacer& operator=(const SegmentPlacer&) { return *this; }         
    6666 
    6767    private: 
    68         osg::Vec3 A_; 
    69         osg::Vec3 B_; 
     68        osg::Vec3 _vertexA; 
     69        osg::Vec3 _vertexB; 
    7070    }; 
    7171 
     
    7373     
    7474    inline SegmentPlacer::SegmentPlacer() 
    75     : Placer(), A_(-1, 0, 0), B_(1, 0, 0) 
     75    : Placer(), _vertexA(-1, 0, 0), _vertexB(1, 0, 0) 
    7676    { 
    7777    } 
    7878     
    79     inline SegmentPlacer::SegmentPlacer(const SegmentPlacer &copy, const osg::CopyOp &copyop) 
    80     : Placer(copy, copyop), A_(copy.A_), B_(copy.B_) 
     79    inline SegmentPlacer::SegmentPlacer(const SegmentPlacer& copy, const osg::CopyOp& copyop) 
     80    : Placer(copy, copyop), _vertexA(copy._vertexA), _vertexB(copy._vertexB) 
    8181    { 
    8282    } 
    8383 
    84     inline const osg::Vec3 &SegmentPlacer::getVertexA() const 
     84    inline const osg::Vec3& SegmentPlacer::getVertexA() const 
    8585    { 
    86         return A_; 
     86        return _vertexA; 
    8787    } 
    8888 
    89     inline const osg::Vec3 &SegmentPlacer::getVertexB() const 
     89    inline const osg::Vec3& SegmentPlacer::getVertexB() const 
    9090    { 
    91         return B_; 
     91        return _vertexB; 
    9292    } 
    9393 
    94     inline void SegmentPlacer::setSegment(const osg::Vec3 &A, const osg::Vec3 &B) 
     94    inline void SegmentPlacer::setSegment(const osg::Vec3& A, const osg::Vec3& B) 
    9595    { 
    96         A_ = A; 
    97         B_ = B; 
     96        _vertexA = A; 
     97        _vertexB = B; 
    9898    } 
    9999 
    100     inline void SegmentPlacer::place(Particle *P) const 
     100    inline void SegmentPlacer::place(Particle* P) const 
    101101    { 
    102         P->setPosition(rangev3(A_, B_).get_random()); 
     102        P->setPosition(rangev3(_vertexA, _vertexB).get_random()); 
    103103    } 
    104104     
    105     inline void SegmentPlacer::setVertexA(const osg::Vec3 &v) 
     105    inline void SegmentPlacer::setVertexA(const osg::Vec3& v) 
    106106    { 
    107         A_ = v; 
     107        _vertexA = v; 
    108108    } 
    109109     
    110110    inline void SegmentPlacer::setVertexA(float x, float y, float z) 
    111111    { 
    112         A_.set(x, y, z); 
     112        _vertexA.set(x, y, z); 
    113113    } 
    114114     
    115     inline void SegmentPlacer::setVertexB(const osg::Vec3 &v) 
     115    inline void SegmentPlacer::setVertexB(const osg::Vec3& v) 
    116116    { 
    117         B_ = v; 
     117        _vertexB = v; 
    118118    } 
    119119 
    120120    inline void SegmentPlacer::setVertexB(float x, float y, float z) 
    121121    { 
    122         B_.set(x, y, z); 
     122        _vertexB.set(x, y, z); 
    123123    }     
    124124 
  • OpenSceneGraph/trunk/include/osgParticle/Shooter

    r4038 r4121  
    1313//osgParticle - Copyright (C) 2002 Marco Jez 
    1414 
    15 #ifndef OSGPARTICLE_SHOOTER_ 
    16 #define OSGPARTICLE_SHOOTER_ 1 
     15#ifndef OSGPARTICLE_SHOOTER 
     16#define OSGPARTICLE_SHOOTER 1 
    1717 
    1818#include <osg/CopyOp> 
     
    2727        Descendants of this class must override the <CODE>shoot()</CODE> method. 
    2828    */ 
    29     class Shooter: public osg::Object { 
     29    class Shooter: public osg::Object 
     30    { 
    3031    public: 
    3132        inline Shooter(); 
    32         inline Shooter(const Shooter &copy, const osg::CopyOp &copyop = osg::CopyOp::SHALLOW_COPY); 
     33        inline Shooter(const Shooter& copy, const osg::CopyOp& copyop = osg::CopyOp::SHALLOW_COPY); 
    3334 
    34         virtual const char *libraryName() const { return "osgParticle"; } 
    35         virtual const char *className() const { return "Shooter"; } 
    36         virtual bool isSameKindAs(const osg::Object *obj) const { return dynamic_cast<const Shooter *>(obj) != 0; } 
     35        virtual const char* libraryName() const { return "osgParticle"; } 
     36        virtual const char* className() const { return "Shooter"; } 
     37        virtual bool isSameKindAs(const osg::Object* obj) const { return dynamic_cast<const Shooter *>(obj) != 0; } 
    3738 
    3839        /**     Shoot a particle. Must be overriden by descendants. 
     
    4041            attributes unchanged. 
    4142        */ 
    42         virtual void shoot(Particle *P) const = 0; 
     43        virtual void shoot(Particle* P) const = 0; 
    4344 
    4445    protected: 
     
    5455    } 
    5556     
    56     inline Shooter::Shooter(const Shooter &copy, const osg::CopyOp &copyop) 
     57    inline Shooter::Shooter(const Shooter& copy, const osg::CopyOp& copyop) 
    5758    : osg::Object(copy, copyop) 
    5859    { 
  • OpenSceneGraph/trunk/include/osgParticle/SmokeEffect

    r4038 r4121  
    1212*/ 
    1313 
    14 #ifndef OSGPARTICLE_SmokeEffect 
    15 #define OSGPARTICLE_SmokeEffect 
     14#ifndef OSGPARTICLE_SMOKEEFFECT 
     15#define OSGPARTICLE_SMOKEEFFECT 
    1616 
    1717#include <osgParticle/ParticleEffect> 
  • OpenSceneGraph/trunk/include/osgParticle/VariableRateCounter

    r4038 r4121  
    1313//osgParticle - Copyright (C) 2002 Marco Jez 
    1414 
    15 #ifndef OSGPARTICLE_VARIABLERATECOUNTER_ 
    16 #define OSGPARTICLE_VARIABLERATECOUNTER_ 1 
     15#ifndef OSGPARTICLE_VARIABLERATE_COUNTER 
     16#define OSGPARTICLE_VARIABLERATE_COUNTER 1 
    1717 
    1818#include <osgParticle/Counter> 
     
    2828    public: 
    2929        inline VariableRateCounter(); 
    30         inline VariableRateCounter(const VariableRateCounter &copy, const osg::CopyOp &copyop = osg::CopyOp::SHALLOW_COPY); 
     30        inline VariableRateCounter(const VariableRateCounter& copy, const osg::CopyOp& copyop = osg::CopyOp::SHALLOW_COPY); 
    3131         
    32         virtual const char *libraryName() const { return "osgParticle"; } 
    33         virtual const char *className() const { return "VariableRateCounter"; } 
    34         virtual bool isSameKindAs(const osg::Object *obj) const { return dynamic_cast<const VariableRateCounter *>(obj) != 0; } 
     32        virtual const char* libraryName() const { return "osgParticle"; } 
     33        virtual const char* className() const { return "VariableRateCounter"; } 
     34        virtual bool isSameKindAs(const osg::Object* obj) const { return dynamic_cast<const VariableRateCounter *>(obj) != 0; } 
    3535         
    36         inline const rangef &getRateRange() const; 
    37         inline void setRateRange(const rangef &r); 
     36        inline const rangef& getRateRange() const; 
     37        inline void setRateRange(const rangef& r); 
    3838        inline void setRateRange(float minrange, float maxrange); 
    3939         
     
    4242         
    4343    private: 
    44         rangef rate_range_; 
     44        rangef _rate_range; 
    4545    }; 
    4646     
     
    4848     
    4949    inline VariableRateCounter::VariableRateCounter() 
    50     : Counter(), rate_range_(1, 1) 
     50    : Counter(), _rate_range(1, 1) 
    5151    { 
    5252    } 
    5353     
    54     inline VariableRateCounter::VariableRateCounter(const VariableRateCounter &copy, const osg::CopyOp &copyop) 
    55     : Counter(copy, copyop), rate_range_(copy.rate_range_) 
     54    inline VariableRateCounter::VariableRateCounter(const VariableRateCounter& copy, const osg::CopyOp& copyop) 
     55    : Counter(copy, copyop), _rate_range(copy._rate_range) 
    5656    { 
    5757    } 
     
    5959    inline const rangef &VariableRateCounter::getRateRange() const 
    6060    { 
    61         return rate_range_; 
     61        return _rate_range; 
    6262    } 
    6363     
    64     inline void VariableRateCounter::setRateRange(const rangef &r) 
     64    inline void VariableRateCounter::setRateRange(const rangef& r) 
    6565    { 
    66         rate_range_ = r; 
     66        _rate_range = r; 
    6767    } 
    6868 
    6969    inline void VariableRateCounter::setRateRange(float minrange, float maxrange) 
    7070    { 
    71         rate_range_.set(minrange, maxrange); 
     71        _rate_range.set(minrange, maxrange); 
    7272    } 
    7373 
  • OpenSceneGraph/trunk/include/osgParticle/Version

    r4038 r4121  
    1313//osgParticle - Copyright (C) 2002 Marco Jez 
    1414 
    15 #ifndef OSGPARTICLE_VERSION_ 
    16 #define OSGPARTICLE_VERSION_ 1 
     15#ifndef OSGPARTICLE_VERSION 
     16#define OSGPARTICLE_VERSION 1 
    1717 
    1818#include <osgParticle/Export> 
  • OpenSceneGraph/trunk/include/osgParticle/range

    r4038 r4121  
    1313//osgParticle - Copyright (C) 2002 Marco Jez 
    1414 
    15 #ifndef OSGPARTICLE_RANGE_ 
    16 #define OSGPARTICLE_RANGE_ 1 
     15#ifndef OSGPARTICLE_RANGE 
     16#define OSGPARTICLE_RANGE 1 
    1717 
    1818// include Export simply to disable Visual Studio silly warnings. 
     
    3636    /** 
    3737        A simple struct template useful to store ranges of values as min/max pairs. 
    38         This struct template helps storing min/max ranges for values of any kind; class <CODE>T_</CODE> is 
    39         the type of values to be stored, and it must support operations <CODE>T_ + T_</CODE>, <CODE>T_ - T_</CODE>,  
    40         and <CODE>T_ * float</CODE>, otherwise the <CODE>get_random()</CODE> method will not compile. 
     38        This struct template helps storing min/max ranges for values of any kind; class <CODE>ValueType</CODE> is 
     39        the type of values to be stored, and it must support operations <CODE>ValueType + ValueType</CODE>, <CODE>ValueType - ValueType</CODE>,  
     40        and <CODE>ValueType * float</CODE>, otherwise the <CODE>geValueTyperandom()</CODE> method will not compile. 
    4141        This struct could be extended to customize the random number generator (now it uses only  
    4242        <CODE>std::rand()</CODE>). 
    4343    */ 
    44     template<class T_> struct range { 
     44    template<class ValueType> struct range 
     45    { 
    4546     
    4647        /// Lower bound. 
    47         T_ minimum; 
     48        ValueType minimum; 
    4849         
    4950        /// Higher bound. 
    50         T_ maximum; 
     51        ValueType maximum; 
    5152 
    5253        /// Construct the object by calling default constructors for min and max. 
    53         range() : minimum(T_()), maximum(T_()) {} 
     54        range() : minimum(ValueType()), maximum(ValueType()) {} 
    5455         
    5556        /// Construct and initialize min and max directly. 
    56         range(const T_ &mn, const T_ &mx) : minimum(mn), maximum(mx) {} 
     57        range(const ValueType& mn, const ValueType& mx) : minimum(mn), maximum(mx) {} 
    5758 
    5859        /// Set min and max. 
    59         void set(const T_ &mn, const T_ &mx) { minimum = mn; maximum = mx; } 
     60        void set(const ValueType& mn, const ValueType& mx) { minimum = mn; maximum = mx; } 
    6061 
    6162        /// Get a random value between min and max. 
    62         T_ get_random() const 
     63        ValueType get_random() const 
    6364        { 
    6465            return minimum + (maximum - minimum) * rand() / RAND_MAX; 
     
    6667 
    6768        /// Get a random square root value between min and max. 
    68         T_ get_random_sqrtf() const 
     69        ValueType get_random_sqrtf() const 
    6970        { 
    7071            return minimum + (maximum - minimum) * sqrtf( static_cast<float>(rand()) / static_cast<float>(RAND_MAX) ); 
  • OpenSceneGraph/trunk/src/osgParticle/Emitter.cpp

    r732 r4121  
    66osgParticle::Emitter::Emitter() 
    77:    ParticleProcessor(),  
    8     usedeftemp_(true) 
     8    _usedeftemp(true) 
    99{ 
    1010} 
    1111 
    12 osgParticle::Emitter::Emitter(const Emitter &copy, const osg::CopyOp &copyop) 
     12osgParticle::Emitter::Emitter(const Emitter& copy, const osg::CopyOp& copyop) 
    1313:     ParticleProcessor(copy, copyop), 
    14     usedeftemp_(copy.usedeftemp_),  
    15     ptemp_(copy.ptemp_) 
     14    _usedeftemp(copy._usedeftemp),  
     15    _ptemp(copy._ptemp) 
    1616{ 
    1717} 
  • OpenSceneGraph/trunk/src/osgParticle/FluidFrictionOperator.cpp

    r3954 r4121  
    77osgParticle::FluidFrictionOperator::FluidFrictionOperator(): 
    88     Operator(), 
    9      A_(0), 
    10      B_(0), 
    11      density_(0), 
    12      viscosity_(0), 
    13      ovr_rad_(0), 
    14      current_program_(0) 
     9     _coeff_A(0), 
     10     _coeff_B(0), 
     11     _density(0), 
     12     _viscosity(0), 
     13     _ovr_rad(0), 
     14     _current_program(0) 
    1515{ 
    1616    setFluidToAir(); 
    1717} 
    1818 
    19 osgParticle::FluidFrictionOperator::FluidFrictionOperator(const FluidFrictionOperator &copy, const osg::CopyOp &copyop) 
     19osgParticle::FluidFrictionOperator::FluidFrictionOperator(const FluidFrictionOperator& copy, const osg::CopyOp& copyop) 
    2020:    Operator(copy, copyop), 
    21     A_(copy.A_), 
    22     B_(copy.B_), 
    23     density_(copy.density_),  
    24     viscosity_(copy.viscosity_), 
    25     ovr_rad_(copy.ovr_rad_), 
    26     current_program_(0) 
     21    _coeff_A(copy._coeff_A), 
     22    _coeff_B(copy._coeff_B), 
     23    _density(copy._density),  
     24    _viscosity(copy._viscosity), 
     25    _ovr_rad(copy._ovr_rad), 
     26    _current_program(0) 
    2727{ 
    2828} 
    2929 
    30 void osgParticle::FluidFrictionOperator::operate(Particle *P, double dt) 
     30void osgParticle::FluidFrictionOperator::operate(Particle* P, double dt) 
    3131{ 
    32     float r = (ovr_rad_ > 0)? ovr_rad_ : P->getRadius(); 
     32    float r = (_ovr_rad > 0)? _ovr_rad : P->getRadius(); 
    3333    osg::Vec3 v = P->getVelocity()-_wind; 
    3434 
    3535    float vm = v.normalize(); 
    36     float R = A_ * r * vm + B_ * r * r * vm * vm; 
     36    float R = _coeff_A * r * vm + _coeff_B * r * r * vm * vm; 
    3737     
    3838    osg::Vec3 Fr(-R * v.x(), -R * v.y(), -R * v.z()); 
    3939 
    40     if (current_program_->getReferenceFrame() == ModularProgram::RELATIVE_RF) { 
    41         Fr = current_program_->rotateLocalToWorld(Fr); 
     40    if (_current_program->getReferenceFrame() == ModularProgram::RELATIVE_RF) { 
     41        Fr = _current_program->rotateLocalToWorld(Fr); 
    4242    } 
    4343 
  • OpenSceneGraph/trunk/src/osgParticle/FluidProgram.cpp

    r4011 r4121  
    2121{ 
    2222    const float four_over_three = 4.0f/3.0f; 
    23     ParticleSystem *ps = getParticleSystem(); 
     23    ParticleSystem* ps = getParticleSystem(); 
    2424    int n = ps->numParticles(); 
    2525    for (int i=0; i<n; ++i) 
    2626    { 
    27         Particle *particle = ps->getParticle(i); 
     27        Particle* particle = ps->getParticle(i); 
    2828        if (particle->isAlive()) 
    2929        { 
  • OpenSceneGraph/trunk/src/osgParticle/ModularEmitter.cpp

    r3528 r4121  
    44osgParticle::ModularEmitter::ModularEmitter() 
    55:    Emitter(), 
    6     counter_(new RandomRateCounter), 
    7     placer_(new PointPlacer), 
    8     shooter_(new RadialShooter) 
     6    _counter(new RandomRateCounter), 
     7    _placer(new PointPlacer), 
     8    _shooter(new RadialShooter) 
    99{ 
    1010} 
    1111     
    12 osgParticle::ModularEmitter::ModularEmitter(const ModularEmitter &copy, const osg::CopyOp &copyop) 
     12osgParticle::ModularEmitter::ModularEmitter(const ModularEmitter& copy, const osg::CopyOp& copyop) 
    1313:    Emitter(copy, copyop), 
    14     counter_(static_cast<Counter *>(copyop(copy.counter_.get()))),  
    15     placer_(static_cast<Placer *>(copyop(copy.placer_.get()))),  
    16     shooter_(static_cast<Shooter *>(copyop(copy.shooter_.get()))) 
     14    _counter(static_cast<Counter *>(copyop(copy._counter.get()))),  
     15    _placer(static_cast<Placer *>(copyop(copy._placer.get()))),  
     16    _shooter(static_cast<Shooter *>(copyop(copy._shooter.get()))) 
    1717{ 
    1818} 
     
    2020void osgParticle::ModularEmitter::emit(double dt)  
    2121{ 
    22     int n = counter_->numParticlesToCreate(dt); 
     22    int n = _counter->numParticlesToCreate(dt); 
    2323    for (int i=0; i<n; ++i) { 
    24         Particle *P = getParticleSystem()->createParticle(getUseDefaultTemplate()? 0: &getParticleTemplate()); 
     24        Particle* P = getParticleSystem()->createParticle(getUseDefaultTemplate()? 0: &getParticleTemplate()); 
    2525        if (P) { 
    26             placer_->place(P); 
    27             shooter_->shoot(P); 
     26            _placer->place(P); 
     27            _shooter->shoot(P); 
    2828            if (getReferenceFrame() == RELATIVE_RF) { 
    2929                P->transformPositionVelocity(getLocalToWorldMatrix()); 
  • OpenSceneGraph/trunk/src/osgParticle/ModularProgram.cpp

    r732 r4121  
    99} 
    1010 
    11 osgParticle::ModularProgram::ModularProgram(const ModularProgram &copy, const osg::CopyOp &copyop) 
     11osgParticle::ModularProgram::ModularProgram(const ModularProgram& copy, const osg::CopyOp& copyop) 
    1212: Program(copy, copyop) 
    1313{ 
    1414    Operator_vector::const_iterator ci; 
    15     for (ci=copy.operators_.begin(); ci!=copy.operators_.end(); ++ci) { 
    16         operators_.push_back(static_cast<Operator *>(copyop(ci->get()))); 
     15    for (ci=copy._operators.begin(); ci!=copy._operators.end(); ++ci) { 
     16        _operators.push_back(static_cast<Operator* >(copyop(ci->get()))); 
    1717    } 
    1818} 
     
    2121{ 
    2222    Operator_vector::iterator ci; 
    23     Operator_vector::iterator ci_end = operators_.end(); 
     23    Operator_vector::iterator ci_end = _operators.end(); 
    2424 
    25     ParticleSystem *ps = getParticleSystem(); 
    26     for (ci=operators_.begin(); ci!=ci_end; ++ci) {         
     25    ParticleSystem* ps = getParticleSystem(); 
     26    for (ci=_operators.begin(); ci!=ci_end; ++ci) {         
    2727        (*ci)->beginOperate(this); 
    2828        int n = ps->numParticles(); 
    2929        for (int i=0; i<n; ++i) { 
    30             Particle *P = ps->getParticle(i); 
     30            Particle* P = ps->getParticle(i); 
    3131            if (P->isAlive() && (*ci)->isEnabled()) { 
    3232                (*ci)->operate(P, dt); 
  • OpenSceneGraph/trunk/src/osgParticle/MultiSegmentPlacer.cpp

    r732 r4121  
    66 
    77osgParticle::MultiSegmentPlacer::MultiSegmentPlacer() 
    8 : Placer(), total_length_(0) 
     8: Placer(), _total_length(0) 
    99{ 
    1010} 
    1111     
    12 osgParticle::MultiSegmentPlacer::MultiSegmentPlacer(const MultiSegmentPlacer &copy, const osg::CopyOp &copyop) 
    13 : Placer(copy, copyop), vx_(copy.vx_), total_length_(copy.total_length_) 
     12osgParticle::MultiSegmentPlacer::MultiSegmentPlacer(const MultiSegmentPlacer& copy, const osg::CopyOp& copyop) 
     13: Placer(copy, copyop), _vx(copy._vx), _total_length(copy._total_length) 
    1414{ 
    1515} 
     
    1818{ 
    1919    Vertex_vector::iterator i; 
    20     Vertex_vector::iterator i0 = vx_.begin(); 
     20    Vertex_vector::iterator i0 = _vx.begin(); 
    2121         
    22     total_length_ = 0; 
    23     for (i=vx_.begin(); i!=vx_.end(); ++i) { 
    24         total_length_ += (i->first - i0->first).length(); 
    25         i->second = total_length_; 
     22    _total_length = 0; 
     23    for (i=_vx.begin(); i!=_vx.end(); ++i) 
     24    { 
     25        _total_length += (i->first - i0->first).length(); 
     26        i->second = _total_length; 
    2627        i0 = i;             
    2728    } 
    2829} 
    2930 
    30 void osgParticle::MultiSegmentPlacer::place(Particle *P) const 
     31void osgParticle::MultiSegmentPlacer::place(Particle* P) const 
    3132{ 
    32     if (vx_.size() >= 2) { 
    33         float x = rangef(0, total_length_).get_random(); 
     33    if (_vx.size() >= 2) { 
     34        float x = rangef(0, _total_length).get_random(); 
    3435         
    3536        Vertex_vector::const_iterator i; 
    36         Vertex_vector::const_iterator i0 = vx_.begin(); 
    37         const Vertex_vector::const_iterator vend = vx_.end(); 
     37        Vertex_vector::const_iterator i0 = _vx.begin(); 
     38        const Vertex_vector::const_iterator vend = _vx.end(); 
    3839 
    39         for (i=vx_.begin(); i!=vend; ++i) { 
    40             if (x <= i->second) { 
     40        for (i=_vx.begin(); i!=vend; ++i) 
     41        { 
     42            if (x <= i->second) 
     43            { 
    4144                float t = (x - i0->second) / (i->second - i0->second); 
    4245                P->setPosition(i0->first + (i->first - i0->first) * t); 
     
    4548            i0 = i; 
    4649        }             
    47     } else { 
     50    } 
     51    else 
     52    { 
    4853        osg::notify(osg::WARN) << "this MultiSegmentPlacer has less than 2 vertices\n"; 
    4954    } 
  • OpenSceneGraph/trunk/src/osgParticle/Particle.cpp

    r3211 r4121  
    2121 
    2222osgParticle::Particle::Particle() 
    23 :   shape_(QUAD), 
    24     sr_(0.2f, 0.2f), 
    25     ar_(1, 0), 
    26     cr_(osg::Vec4(1, 1, 1, 1), osg::Vec4(1, 1, 1, 1)), 
    27     si_(new LinearInterpolator),  
    28     ai_(new LinearInterpolator),  
    29     ci_(new LinearInterpolator), 
    30     alive_(true), 
    31     mustdie_(false), 
    32     lifetime_(2), 
    33     radius_(0.2f), 
    34     mass_(0.1f), 
    35     massinv_(10.0f), 
    36     prev_pos_(0, 0, 0), 
    37     position_(0, 0, 0), 
    38     velocity_(0, 0, 0), 
    39     prev_angle_(0, 0, 0), 
    40     angle_(0, 0, 0), 
    41     angular_vel_(0, 0, 0), 
    42     t0_(0), 
    43     current_size_(0), 
    44     current_alpha_(0), 
    45         s_tile_(1.0f), 
    46     t_tile_(1.0f), 
    47         num_tile_(1), 
    48         cur_tile_(-1), 
    49         s_coord_(0.0f), 
    50         t_coord_(0.0f) 
     23:   _shape(QUAD), 
     24    _sr(0.2f, 0.2f), 
     25    _ar(1, 0), 
     26    _cr(osg::Vec4(1, 1, 1, 1), osg::Vec4(1, 1, 1, 1)), 
     27    _si(new LinearInterpolator),  
     28    _ai(new LinearInterpolator),  
     29    _ci(new LinearInterpolator), 
     30    _alive(true), 
     31    _mustdie(false), 
     32    _lifeTime(2), 
     33    _radius(0.2f), 
     34    _mass(0.1f), 
     35    _massinv(10.0f), 
     36    _prev_pos(0, 0, 0), 
     37    _position(0, 0, 0), 
     38    _velocity(0, 0, 0), 
     39    _prev_angle(0, 0, 0), 
     40    _angle(0, 0, 0), 
     41    _angul_arvel(0, 0, 0), 
     42    _t0(0), 
     43    _current_size(0), 
     44    _current_alpha(0), 
     45    _s_tile(1.0f), 
     46    _t_tile(1.0f), 
     47    _num_tile(1), 
     48    _cur_tile(-1), 
     49    _s_coord(0.0f), 
     50    _t_coord(0.0f) 
    5151{ 
    5252} 
     
    5656    // this method should return false when the particle dies; 
    5757    // so, if we were instructed to die, do it now and return. 
    58     if (mustdie_) { 
    59         alive_ = false; 
     58    if (_mustdie) { 
     59        _alive = false; 
    6060        return false; 
    6161    } 
     
    6464 
    6565    // if we don't live forever, compute our normalized age. 
    66     if (lifetime_ > 0) { 
    67         x = t0_ / lifetime_; 
    68     } 
    69  
    70     t0_ += dt; 
     66    if (_lifeTime > 0) { 
     67        x = _t0 / _lifeTime; 
     68    } 
     69 
     70    _t0 += dt; 
    7171 
    7272    // if our age is over the lifetime limit, then die and return. 
    7373    if (x > 1) { 
    74         alive_ = false; 
     74        _alive = false; 
    7575        return false; 
    7676    } 
    7777 
    78         //Compute the current texture tile based on our normalized age 
    79         int currentTile = static_cast<int>(x * num_tile_); 
    80          
    81         //If the current texture tile is different from previous, then compute new texture coords 
    82         if(currentTile != cur_tile_) { 
    83                 cur_tile_ = currentTile; 
    84                 s_coord_ = s_tile_ * fmod(cur_tile_ , 1.0 / s_tile_); 
    85                 t_coord_ = 1.0 - t_tile_ * (static_cast<int>(cur_tile_ * t_tile_) + 1); 
    86         } 
    87          
     78    //Compute the current texture tile based on our normalized age 
     79    int currentTile = static_cast<int>(x * _num_tile); 
     80     
     81    //If the current texture tile is different from previous, then compute new texture coords 
     82    if(currentTile != _cur_tile) { 
     83        _cur_tile = currentTile; 
     84        _s_coord = _s_tile * fmod(_cur_tile , 1.0 / _s_tile); 
     85        _t_coord = 1.0 - _t_tile * (static_cast<int>(_cur_tile * _t_tile) + 1); 
     86    } 
     87     
    8888    // compute the current values for size, alpha and color. 
    89     if (lifetime_ <= 0) { 
    90        if (dt == t0_) { 
    91           current_size_ = sr_.get_random(); 
    92           current_alpha_ = ar_.get_random(); 
    93           current_color_ = cr_.get_random(); 
     89    if (_lifeTime <= 0) { 
     90       if (dt == _t0) { 
     91          _current_size = _sr.get_random(); 
     92          _current_alpha = _ar.get_random(); 
     93          _current_color = _cr.get_random(); 
    9494       } 
    9595    } else { 
    96        current_size_ = si_.get()->interpolate(x, sr_); 
    97        current_alpha_ = ai_.get()->interpolate(x, ar_); 
    98        current_color_ = ci_.get()->interpolate(x, cr_); 
     96       _current_size = _si.get()->interpolate(x, _sr); 
     97       _current_alpha = _ai.get()->interpolate(x, _ar); 
     98       _current_color = _ci.get()->interpolate(x, _cr); 
    9999    } 
    100100 
    101101    // update position 
    102     prev_pos_ = position_; 
    103     position_ += velocity_ * dt; 
     102    _prev_pos = _position; 
     103    _position += _velocity * dt; 
    104104 
    105105    // update angle 
    106     prev_angle_ = angle_; 
    107     angle_ += angular_vel_ * dt; 
    108  
    109     if (angle_.x() > osg::PI*2) angle_.x() -= osg::PI*2; 
    110     if (angle_.x() < -osg::PI*2) angle_.x() += osg::PI*2; 
    111     if (angle_.y() > osg::PI*2) angle_.y() -= osg::PI*2; 
    112     if (angle_.y() < -osg::PI*2) angle_.y() += osg::PI*2; 
    113     if (angle_.z() > osg::PI*2) angle_.z() -= osg::PI*2; 
    114     if (angle_.z() < -osg::PI*2) angle_.z() += osg::PI*2; 
     106    _prev_angle = _angle; 
     107    _angle += _angul_arvel * dt; 
     108 
     109    if (_angle.x() > osg::PI*2) _angle.x() -= osg::PI*2; 
     110    if (_angle.x() < -osg::PI*2) _angle.x() += osg::PI*2; 
     111    if (_angle.y() > osg::PI*2) _angle.y() -= osg::PI*2; 
     112    if (_angle.y() < -osg::PI*2) _angle.y() += osg::PI*2; 
     113    if (_angle.z() > osg::PI*2) _angle.z() -= osg::PI*2; 
     114    if (_angle.z() < -osg::PI*2) _angle.z() += osg::PI*2; 
    115115 
    116116    return true; 
    117117} 
    118118 
    119 void osgParticle::Particle::render(const osg::Vec3 &xpos, const osg::Vec3 &px, const osg::Vec3 &py, float scale) const 
    120 { 
    121     glColor4f(  current_color_.x(),  
    122                 current_color_.y(),  
    123                 current_color_.z(),  
    124                 current_color_.w() * current_alpha_); 
     119void osgParticle::Particle::render(const osg::Vec3& xpos, const osg::Vec3& px, const osg::Vec3& py, float scale) const 
     120{ 
     121    glColor4f(  _current_color.x(),  
     122                _current_color.y(),  
     123                _current_color.z(),  
     124                _current_color.w() * _current_alpha); 
    125125 
    126126    osg::Matrix R; 
    127127    R.makeRotate( 
    128         angle_.x(), osg::Vec3(1, 0, 0),  
    129         angle_.y(), osg::Vec3(0, 1, 0),  
    130         angle_.z(), osg::Vec3(0, 0, 1)); 
    131  
    132     osg::Vec3 p1(px * current_size_ * scale); 
    133     osg::Vec3 p2(py * current_size_ * scale); 
    134  
    135     switch (shape_) 
     128        _angle.x(), osg::Vec3(1, 0, 0),  
     129        _angle.y(), osg::Vec3(0, 1, 0),  
     130        _angle.z(), osg::Vec3(0, 0, 1)); 
     131 
     132    osg::Vec3 p1(px * _current_size * scale); 
     133    osg::Vec3 p2(py * _current_size * scale); 
     134 
     135    switch (_shape) 
    136136    { 
    137137    case POINT:         
     
    140140 
    141141    case QUAD: 
    142         glTexCoord2f(s_coord_, t_coord_); 
     142        glTexCoord2f(_s_coord, _t_coord); 
    143143        glVertex3fv((xpos-(p1+p2)*R).ptr()); 
    144         glTexCoord2f(s_coord_+s_tile_, t_coord_); 
     144        glTexCoord2f(_s_coord+_s_tile, _t_coord); 
    145145        glVertex3fv((xpos+(p1-p2)*R).ptr()); 
    146         glTexCoord2f(s_coord_+s_tile_, t_coord_+t_tile_); 
     146        glTexCoord2f(_s_coord+_s_tile, _t_coord+_t_tile); 
    147147        glVertex3fv((xpos+(p1+p2)*R).ptr()); 
    148         glTexCoord2f(s_coord_, t_coord_+t_tile_); 
     148        glTexCoord2f(_s_coord, _t_coord+_t_tile); 
    149149        glVertex3fv((xpos-(p1-p2)*R).ptr()); 
    150150        break; 
     
    156156        // we must glBegin() and glEnd() here, because each particle is a single strip 
    157157        glBegin(GL_TRIANGLE_STRIP); 
    158         glTexCoord2f(s_coord_+s_tile_, t_coord_+t_tile_); 
     158        glTexCoord2f(_s_coord+_s_tile, _t_coord+_t_tile); 
    159159        glVertex3fv((p1+p2).ptr());       
    160         glTexCoord2f(s_coord_, t_coord_+t_tile_); 
     160        glTexCoord2f(_s_coord, _t_coord+_t_tile); 
    161161        glVertex3fv((-p1+p2).ptr());         
    162         glTexCoord2f(s_coord_+s_tile_, t_coord_); 
     162        glTexCoord2f(_s_coord+_s_tile, _t_coord); 
    163163        glVertex3fv((p1-p2).ptr()); 
    164         glTexCoord2f(s_coord_, t_coord_); 
     164        glTexCoord2f(_s_coord, _t_coord); 
    165165        glVertex3fv((-p1-p2).ptr()); 
    166166        glEnd(); 
     
    174174        // we must glBegin() and glEnd() here, because each particle is a single fan 
    175175        glBegin(GL_TRIANGLE_FAN); 
    176         glTexCoord2f(s_coord_ + s_tile_ * 0.5f, t_coord_ + t_tile_ * 0.5f); 
     176        glTexCoord2f(_s_coord + _s_tile * 0.5f, _t_coord + _t_tile * 0.5f); 
    177177        glVertex3f(0,0,0); 
    178         glTexCoord2f(s_coord_ + s_tile_ * hex_texcoord_x1, t_coord_ + t_tile_ * hex_texcoord_y1); 
     178        glTexCoord2f(_s_coord + _s_tile * hex_texcoord_x1, _t_coord + _t_tile * hex_texcoord_y1); 
    179179        glVertex3fv((p1*cosPI3+p2*sinPI3).ptr()); 
    180         glTexCoord2f(s_coord_ + s_tile_ * hex_texcoord_x2, t_coord_ + t_tile_ * hex_texcoord_y1); 
     180        glTexCoord2f(_s_coord + _s_tile * hex_texcoord_x2, _t_coord + _t_tile * hex_texcoord_y1); 
    181181        glVertex3fv((-p1*cosPI3+p2*sinPI3).ptr()); 
    182         glTexCoord2f(s_coord_, t_coord_ + t_tile_ * 0.5f); 
     182        glTexCoord2f(_s_coord, _t_coord + _t_tile * 0.5f); 
    183183        glVertex3fv((-p1).ptr()); 
    184         glTexCoord2f(s_coord_ + s_tile_ * hex_texcoord_x2, t_coord_ + t_tile_ * hex_texcoord_y2); 
     184        glTexCoord2f(_s_coord + _s_tile * hex_texcoord_x2, _t_coord + _t_tile * hex_texcoord_y2); 
    185185        glVertex3fv((-p1*cosPI3-p2*sinPI3).ptr()); 
    186         glTexCoord2f(s_coord_ + s_tile_ * hex_texcoord_x1, t_coord_ + t_tile_ * hex_texcoord_y2); 
     186        glTexCoord2f(_s_coord + _s_tile * hex_texcoord_x1, _t_coord + _t_tile * hex_texcoord_y2); 
    187187        glVertex3fv((p1*cosPI3-p2*sinPI3).ptr()); 
    188         glTexCoord2f(s_coord_ + s_tile_, t_coord_ + t_tile_ * 0.5f); 
     188        glTexCoord2f(_s_coord + _s_tile, _t_coord + _t_tile * 0.5f); 
    189189        glVertex3fv((p1).ptr()); 
    190         glTexCoord2f(s_coord_ + s_tile_ * hex_texcoord_x1, t_coord_ + t_tile_ * hex_texcoord_y1); 
     190        glTexCoord2f(_s_coord + _s_tile * hex_texcoord_x1, _t_coord + _t_tile * hex_texcoord_y1); 
    191191        glVertex3fv((p1*cosPI3+p2*sinPI3).ptr()); 
    192192        glEnd(); 
     
    198198            // Get the normalized direction of the particle, to be used in the  
    199199            // calculation of one of the linesegment endpoints. 
    200             float vl = velocity_.length(); 
     200            float vl = _velocity.length(); 
    201201            if (vl != 0) { 
    202                 osg::Vec3 v = velocity_ * current_size_ * scale / vl; 
     202                osg::Vec3 v = _velocity * _current_size * scale / vl; 
    203203 
    204204                glTexCoord1f(0); 
  • OpenSceneGraph/trunk/src/osgParticle/ParticleProcessor.cpp

    r3528 r4121  
    1414osgParticle::ParticleProcessor::ParticleProcessor() 
    1515:    osg::Node(), 
    16     rf_(RELATIVE_RF), 
    17     enabled_(true), 
    18     t0_(-1), 
    19     ps_(0), 
    20     need_ltw_matrix_(false), 
    21     need_wtl_matrix_(false), 
    22     current_nodevisitor_(0), 
    23     endless_(true), 
    24     lifeTime_(0.0), 
    25     startTime_(0.0), 
    26     currentTime_(0.0), 
    27     resetTime_(0.0) 
     16    _rf(RELATIVE_RF), 
     17    _enabled(true), 
     18    _t0(-1), 
     19    _ps(0), 
     20    _need_ltw_matrix(false), 
     21    _need_wtl_matrix(false), 
     22    _current_nodevisitor(0), 
     23    _endless(true), 
     24    _lifeTime(0.0), 
     25    _startTime(0.0), 
     26    _currentTime(0.0), 
     27    _resetTime(0.0) 
    2828{ 
    2929    setCullingActive(false); 
    3030} 
    3131 
    32 osgParticle::ParticleProcessor::ParticleProcessor(const ParticleProcessor &copy, const osg::CopyOp &copyop) 
     32osgParticle::ParticleProcessor::ParticleProcessor(const ParticleProcessor& copy, const osg::CopyOp& copyop) 
    3333:    osg::Node(copy, copyop), 
    34     rf_(copy.rf_), 
    35     enabled_(copy.enabled_), 
    36     t0_(copy.t0_), 
    37     ps_(static_cast<ParticleSystem *>(copyop(copy.ps_.get()))), 
    38     need_ltw_matrix_(copy.need_ltw_matrix_), 
    39     need_wtl_matrix_(copy.need_wtl_matrix_), 
    40     current_nodevisitor_(0), 
    41     endless_(copy.endless_), 
    42     lifeTime_(copy.lifeTime_), 
    43     startTime_(copy.startTime_), 
    44     currentTime_(copy.currentTime_), 
    45     resetTime_(copy.resetTime_) 
     34    _rf(copy._rf), 
     35    _enabled(copy._enabled), 
     36    _t0(copy._t0), 
     37    _ps(static_cast<ParticleSystem* >(copyop(copy._ps.get()))), 
     38    _need_ltw_matrix(copy._need_ltw_matrix), 
     39    _need_wtl_matrix(copy._need_wtl_matrix), 
     40    _current_nodevisitor(0), 
     41    _endless(copy._endless), 
     42    _lifeTime(copy._lifeTime), 
     43    _startTime(copy._startTime), 
     44    _currentTime(copy._currentTime), 
     45    _resetTime(copy._resetTime) 
    4646{ 
    4747} 
    4848 
    49 void osgParticle::ParticleProcessor::traverse(osg::NodeVisitor &nv) 
     49void osgParticle::ParticleProcessor::traverse(osg::NodeVisitor& nv) 
    5050{ 
    5151    // typecast the NodeVisitor to CullVisitor 
    52     osgUtil::CullVisitor *cv = dynamic_cast<osgUtil::CullVisitor *>(&nv); 
     52    osgUtil::CullVisitor* cv = dynamic_cast<osgUtil::CullVisitor*>(&nv); 
    5353 
    5454    // continue only if the visitor actually is a cull visitor 
     
    5656 
    5757        // continue only if the particle system is valid 
    58         if (ps_.valid()) 
     58        if (_ps.valid()) 
    5959        { 
    6060 
     
    6666 
    6767                // reset this processor if we've reached the reset point 
    68                 if ((currentTime_ >= resetTime_) && (resetTime_ > 0)) { 
    69                     currentTime_ = 0; 
    70                     t0_ = -1; 
     68                if ((_currentTime >= _resetTime) && (_resetTime > 0)) 
     69                { 
     70                    _currentTime = 0; 
     71                    _t0 = -1; 
    7172                } 
    7273 
    73                 // skip if we haven't initialized t0_ yet 
    74                 if (t0_ != -1) { 
     74                // skip if we haven't initialized _t0 yet 
     75                if (_t0 != -1) 
     76                { 
    7577 
    7678                    // check whether the processor is alive 
    7779                    bool alive = false; 
    78                     if (currentTime_ >= startTime_)    { 
    79                         if (endless_ || (currentTime_ < (startTime_ + lifeTime_))) 
     80                    if (_currentTime >= _startTime) 
     81                    { 
     82                        if (_endless || (_currentTime < (_startTime + _lifeTime))) 
    8083                            alive = true; 
    8184                    } 
    8285 
    8386                    // update current time 
    84                     currentTime_ += t - t0_; 
     87                    _currentTime += t - _t0; 
    8588 
    8689                    // process only if the particle system is not frozen/culled 
    8790                    if (alive &&  
    88                         enabled_ &&  
    89                         !ps_->isFrozen() &&  
    90                         (ps_->getLastFrameNumber() >= (nv.getFrameStamp()->getFrameNumber() - 1) || !ps_->getFreezeOnCull())) { 
    91  
     91                        _enabled &&  
     92                        !_ps->isFrozen() &&  
     93                        (_ps->getLastFrameNumber() >= (nv.getFrameStamp()->getFrameNumber() - 1) || !_ps->getFreezeOnCull())) 
     94                    { 
    9295                        // initialize matrix flags 
    93                         need_ltw_matrix_ = true; 
    94                         need_wtl_matrix_ = true; 
    95                         current_nodevisitor_ = &nv; 
     96                        _need_ltw_matrix = true; 
     97                        _need_wtl_matrix = true; 
     98                        _current_nodevisitor = &nv; 
    9699 
    97100                        // do some process (unimplemented in this base class) 
    98                         process(t - t0_); 
     101                        process(t - _t0); 
    99102                    } 
    100103                } 
    101104 
    102                 // update t0_ 
    103                 t0_ = t; 
     105                // update _t0 
     106                _t0 = t; 
    104107 
    105108            } 
  • OpenSceneGraph/trunk/src/osgParticle/ParticleSystem.cpp

    r2423 r4121  
    1919osgParticle::ParticleSystem::ParticleSystem() 
    2020:    osg::Drawable(),  
    21     def_bbox_(osg::Vec3(-10, -10, -10), osg::Vec3(10, 10, 10)), 
    22     alignment_(BILLBOARD), 
    23     align_X_axis_(1, 0, 0), 
    24     align_Y_axis_(0, 1, 0), 
    25     doublepass_(false), 
    26     frozen_(false), 
    27     bmin_(0, 0, 0),  
    28     bmax_(0, 0, 0),  
    29     reset_bounds_flag_(false), 
    30     bounds_computed_(false), 
    31     def_ptemp_(Particle()), 
    32     last_frame_(0), 
    33     freeze_on_cull_(false), 
    34     detail_(1), 
    35     draw_count_(0) 
     21    _def_bbox(osg::Vec3(-10, -10, -10), osg::Vec3(10, 10, 10)), 
     22    _alignment(BILLBOARD), 
     23    _align_X_axis(1, 0, 0), 
     24    _align_Y_axis(0, 1, 0), 
     25    _doublepass(false), 
     26    _frozen(false), 
     27    _bmin(0, 0, 0),  
     28    _bmax(0, 0, 0),  
     29    _reset_bounds_flag(false), 
     30    _bounds_computed(false), 
     31    _def_ptemp(Particle()), 
     32    _last_frame(0), 
     33    _freeze_on_cull(false), 
     34    _detail(1), 
     35    _draw_count(0) 
    3636{ 
    3737    // we don't support display lists because particle systems 
     
    4040} 
    4141 
    42 osgParticle::ParticleSystem::ParticleSystem(const ParticleSystem &copy, const osg::CopyOp &copyop) 
     42osgParticle::ParticleSystem::ParticleSystem(const ParticleSystem& copy, const osg::CopyOp& copyop) 
    4343:    osg::Drawable(copy, copyop),  
    44     def_bbox_(copy.def_bbox_), 
    45     alignment_(copy.alignment_), 
    46     align_X_axis_(copy.align_X_axis_), 
    47     align_Y_axis_(copy.align_Y_axis_), 
    48     doublepass_(copy.doublepass_), 
    49     frozen_(copy.frozen_), 
    50     bmin_(copy.bmin_),  
    51     bmax_(copy.bmax_),  
    52     reset_bounds_flag_(copy.reset_bounds_flag_), 
    53     bounds_computed_(copy.bounds_computed_), 
    54     def_ptemp_(copy.def_ptemp_), 
    55     last_frame_(copy.last_frame_), 
    56     freeze_on_cull_(copy.freeze_on_cull_), 
    57     detail_(copy.detail_), 
    58     draw_count_(0) 
     44    _def_bbox(copy._def_bbox), 
     45    _alignment(copy._alignment), 
     46    _align_X_axis(copy._align_X_axis), 
     47    _align_Y_axis(copy._align_Y_axis), 
     48    _doublepass(copy._doublepass), 
     49    _frozen(copy._frozen), 
     50    _bmin(copy._bmin),  
     51    _bmax(copy._bmax),  
     52    _reset_bounds_flag(copy._reset_bounds_flag), 
     53    _bounds_computed(copy._bounds_computed), 
     54    _def_ptemp(copy._def_ptemp), 
     55    _last_frame(copy._last_frame), 
     56    _freeze_on_cull(copy._freeze_on_cull), 
     57    _detail(copy._detail), 
     58    _draw_count(0) 
    5959{ 
    6060} 
     
    6767{ 
    6868    // reset bounds 
    69     reset_bounds_flag_ = true; 
     69    _reset_bounds_flag = true; 
    7070 
    7171    // set up iterators for particles 
    7272    Particle_vector::iterator i; 
    73     Particle_vector::iterator end = particles_.end(); 
     73    Particle_vector::iterator end = _particles.end(); 
    7474 
    7575    // update particles 
    76     for (i=particles_.begin(); i!=end; ++i) { 
     76    for (i=_particles.begin(); i!=end; ++i) { 
    7777        if (i->isAlive()) { 
    7878            if (i->update(dt)) { 
    7979                update_bounds(i->getPosition(), i->getCurrentSize()); 
    8080            } else { 
    81                 deadparts_.push(&(*i)); 
     81                _deadparts.push(&(*i)); 
    8282            } 
    8383        } 
     
    8888} 
    8989 
    90 void osgParticle::ParticleSystem::drawImplementation(osg::State &state) const 
     90void osgParticle::ParticleSystem::drawImplementation(osg::State& state) const 
    9191{ 
    9292    // update the frame count, so other objects can detect when 
    9393    // this particle system is culled 
    94     last_frame_ = state.getFrameStamp()->getFrameNumber(); 
     94    _last_frame = state.getFrameStamp()->getFrameNumber(); 
    9595 
    9696    // get the current modelview matrix 
    9797    osg::Matrix modelview = state.getModelViewMatrix(); 
    9898 
    99     if (alignment_ == BILLBOARD) 
     99    if (_alignment == BILLBOARD) 
    100100        state.applyModelViewMatrix(0); 
    101101 
     
    111111 
    112112    // render, second pass 
    113     if (doublepass_) {     
     113    if (_doublepass) {     
    114114        // set up color mask for second rendering pass 
    115115        glPushAttrib(GL_COLOR_BUFFER_BIT); 
     
    124124} 
    125125 
    126 void osgParticle::ParticleSystem::setDefaultAttributes(const std::string &texturefile, bool emissive_particles, bool lighting, int texture_unit) 
     126void osgParticle::ParticleSystem::setDefaultAttributes(const std::string& texturefile, bool emissive_particles, bool lighting, int texture_unit) 
    127127{ 
    128128    osg::StateSet *stateset = new osg::StateSet; 
     
    161161 
    162162 
    163 void osgParticle::ParticleSystem::single_pass_render(osg::State & /*state*/, const osg::Matrix &modelview) const 
     163void osgParticle::ParticleSystem::single_pass_render(osg::State&  /*state*/, const osg::Matrix& modelview) const 
    164164{ 
    165     draw_count_ = 0; 
    166     if (particles_.size() <= 0) return; 
     165    _draw_count = 0; 
     166    if (_particles.size() <= 0) return; 
    167167 
    168168    Particle_vector::const_iterator i; 
    169     Particle_vector::const_iterator i0 = particles_.begin(); 
    170     Particle_vector::const_iterator end = particles_.end(); 
     169    Particle_vector::const_iterator i0 = _particles.begin(); 
     170    Particle_vector::const_iterator end = _particles.end(); 
    171171     
    172172    i0->beginRender(); 
    173173 
    174     float scale = sqrtf(static_cast<float>(detail_)); 
    175     for (i=i0; i<end; i+=detail_) { 
     174    float scale = sqrtf(static_cast<float>(_detail)); 
     175    for (i=i0; i<end; i+=_detail) { 
    176176        if (i->isAlive()) { 
    177177            if (i->getShape() != i0->getShape()) { 
     
    180180                i0 = i; 
    181181            } 
    182             ++draw_count_; 
     182            ++_draw_count; 
    183183 
    184             switch (alignment_) { 
     184            switch (_alignment) { 
    185185                case BILLBOARD: 
    186186                    i->render(modelview.preMult(i->getPosition()), osg::Vec3(1, 0, 0), osg::Vec3(0, 1, 0), scale); 
    187187                    break; 
    188188                case FIXED: 
    189                     i->render(i->getPosition(), align_X_axis_, align_Y_axis_, scale); 
     189                    i->render(i->getPosition(), _align_X_axis, _align_Y_axis, scale); 
    190190                    break; 
    191191                default: ; 
  • OpenSceneGraph/trunk/src/osgParticle/ParticleSystemUpdater.cpp

    r1385 r4121  
    77 
    88osgParticle::ParticleSystemUpdater::ParticleSystemUpdater() 
    9 : osg::Node(), t0_(-1) 
     9: osg::Node(), _t0(-1) 
    1010{ 
    1111    setCullingActive(false); 
    1212} 
    1313 
    14 osgParticle::ParticleSystemUpdater::ParticleSystemUpdater(const ParticleSystemUpdater &copy, const osg::CopyOp &copyop) 
    15 : osg::Node(copy, copyop), t0_(copy.t0_) 
     14osgParticle::ParticleSystemUpdater::ParticleSystemUpdater(const ParticleSystemUpdater& copy, const osg::CopyOp& copyop) 
     15: osg::Node(copy, copyop), _t0(copy._t0) 
    1616{ 
    1717    ParticleSystem_Vector::const_iterator i; 
    18     for (i=copy.psv_.begin(); i!=copy.psv_.end(); ++i) { 
    19         psv_.push_back(static_cast<ParticleSystem *>(copyop(i->get()))); 
     18    for (i=copy._psv.begin(); i!=copy._psv.end(); ++i) { 
     19        _psv.push_back(static_cast<ParticleSystem* >(copyop(i->get()))); 
    2020    } 
    2121} 
    2222 
    23 void osgParticle::ParticleSystemUpdater::traverse(osg::NodeVisitor &nv) 
     23void osgParticle::ParticleSystemUpdater::traverse(osg::NodeVisitor& nv) 
    2424{ 
    2525    osgUtil::CullVisitor *cv = dynamic_cast<osgUtil::CullVisitor *>(&nv); 
     
    2828        { 
    2929            double t = nv.getFrameStamp()->getReferenceTime(); 
    30             if (t0_ != -1) 
     30            if (_t0 != -1) 
    3131            { 
    3232                ParticleSystem_Vector::iterator i; 
    33                 for (i=psv_.begin(); i!=psv_.end(); ++i) 
     33                for (i=_psv.begin(); i!=_psv.end(); ++i) 
    3434                { 
    3535                    if (!i->get()->isFrozen() && (i->get()->getLastFrameNumber() >= (nv.getFrameStamp()->getFrameNumber() - 1) || !i->get()->getFreezeOnCull())) 
    3636                    { 
    37                         i->get()->update(t - t0_); 
     37                        i->get()->update(t - _t0); 
    3838                    } 
    3939                } 
    4040            } 
    41             t0_ = t; 
     41            _t0 = t; 
    4242        } 
    4343        else 
  • OpenSceneGraph/trunk/src/osgParticle/Program.cpp

    r732 r4121  
    99} 
    1010 
    11 osgParticle::Program::Program(const Program &copy, const osg::CopyOp &copyop) 
     11osgParticle::Program::Program(const Program& copy, const osg::CopyOp& copyop) 
    1212:    ParticleProcessor(copy, copyop) 
    1313{