Show
Ignore:
Timestamp:
03/21/12 18:36:20 (2 years ago)
Author:
robert
Message:

Ran script to remove trailing spaces and tabs

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • OpenSceneGraph/trunk/include/osgParticle/ParticleProcessor

    r12056 r13041  
    1 /* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield  
     1/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield 
    22 * 
    3  * This library is open source and may be redistributed and/or modified under   
    4  * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or  
     3 * This library is open source and may be redistributed and/or modified under 
     4 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or 
    55 * (at your option) any later version.  The full license is in LICENSE file 
    66 * included with this distribution, and on the openscenegraph.org website. 
    7  *  
     7 * 
    88 * This library is distributed in the hope that it will be useful, 
    99 * but WITHOUT ANY WARRANTY; without even the implied warranty of 
    10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the  
     10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
    1111 * OpenSceneGraph Public License for more details. 
    1212*/ 
     
    3838    class OSGPARTICLE_EXPORT ParticleProcessor: public osg::Node { 
    3939    public: 
    40      
     40 
    4141        enum ReferenceFrame { 
    4242            RELATIVE_RF, 
    4343            ABSOLUTE_RF 
    4444        }; 
    45          
     45 
    4646        ParticleProcessor(); 
    4747        ParticleProcessor(const ParticleProcessor& copy, const osg::CopyOp& copyop = osg::CopyOp::SHALLOW_COPY); 
     
    5050        virtual const char* className() const { return "ParticleProcessor"; } 
    5151        virtual bool isSameKindAs(const osg::Object* obj) const { return dynamic_cast<const ParticleProcessor*>(obj) != 0; } 
    52         virtual void accept(osg::NodeVisitor& nv) { if (nv.validNodeMask(*this)) { nv.pushOntoNodePath(this); nv.apply(*this); nv.popFromNodePath(); } }         
    53          
     52        virtual void accept(osg::NodeVisitor& nv) { if (nv.validNodeMask(*this)) { nv.pushOntoNodePath(this); nv.apply(*this); nv.popFromNodePath(); } } 
     53 
    5454        /// Get the reference frame. 
    5555        inline ReferenceFrame getReferenceFrame() const; 
    56          
     56 
    5757        /// Set the reference frame. 
    5858        inline void setReferenceFrame(ReferenceFrame rf); 
    59          
     59 
    6060        /// Get whether this processor is enabled or not. 
    6161        bool getEnabled() const { return _enabled; } 
    6262        inline bool isEnabled() const; 
    63          
     63 
    6464        /// Set whether this processor is enabled or not. 
    6565        inline void setEnabled(bool v); 
    66          
     66 
    6767        /// Get a pointer to the destination particle system. 
    6868        inline ParticleSystem* getParticleSystem(); 
    69          
     69 
    7070        /// Get a const pointer to the destination particle system. 
    7171        inline const ParticleSystem* getParticleSystem() const; 
    72          
     72 
    7373        /// Set the destination particle system. 
    7474        inline void setParticleSystem(ParticleSystem* ps); 
    75          
     75 
    7676        /// Set the endless flag of this processor. 
    7777        inline void setEndless(bool type); 
    78          
     78 
    7979        /// Check whether this processor is endless. 
    8080        bool getEndless() const { return _endless; } 
    8181        inline bool isEndless() const; 
    82          
     82 
    8383        /// Set the lifetime of this processor. 
    8484        inline void setLifeTime(double t); 
    85          
     85 
    8686        /// Get the lifetime of this processor. 
    8787        inline double getLifeTime() const; 
    88          
     88 
    8989        /// Set the start time of this processor. 
    9090        inline void setStartTime(double t); 
    91          
     91 
    9292        /// Get the start time of this processor. 
    9393        inline double getStartTime() const; 
     
    9595        /// Set the current time of this processor. 
    9696        inline void setCurrentTime(double t); 
    97          
     97 
    9898        /// Get the current time of this processor. 
    9999        inline double getCurrentTime() const; 
    100          
     100 
    101101        /// Set the reset time of this processor. A value of 0 disables reset. 
    102102        inline void setResetTime(double t); 
    103          
     103 
    104104        /// Get the reset time of this processor. 
    105105        inline double getResetTime() const; 
    106          
     106 
    107107        /** 
    108108          Check whether the processor is alive with respect to start time and 
    109           life duration. Note that this method may return true even if the  
     109          life duration. Note that this method may return true even if the 
    110110          processor has been disabled by calling setEnabled(false). To test 
    111111          whether the processor is actually processing particles or not, you 
     
    113113         */ 
    114114        inline bool isAlive() const; 
    115          
     115 
    116116        void traverse(osg::NodeVisitor& nv); 
    117117 
    118118        /// Get the current local-to-world transformation matrix (valid only during cull traversal). 
    119119        inline const osg::Matrix& getLocalToWorldMatrix(); 
    120          
     120 
    121121        /// Get the current world-to-local transformation matrix (valid only during cull traversal). 
    122122        inline const osg::Matrix& getWorldToLocalMatrix(); 
    123          
     123 
    124124        /// Get the previous local-to-world transformation matrix (valid only during cull traversal). 
    125125        inline const osg::Matrix& getPreviousLocalToWorldMatrix(); 
    126          
     126 
    127127        /// Get the previous world-to-local transformation matrix (valid only during cull traversal). 
    128128        inline const osg::Matrix& getPreviousWorldToLocalMatrix(); 
     
    131131        /// Transform a point from local to world coordinates (valid only during cull traversal). 
    132132        inline osg::Vec3 transformLocalToWorld(const osg::Vec3& P); 
    133          
     133 
    134134        /// Transform a vector from local to world coordinates, discarding translation (valid only during cull traversal). 
    135135        inline osg::Vec3 rotateLocalToWorld(const osg::Vec3& P); 
    136          
     136 
    137137        /// Transform a point from world to local coordinates (valid only during cull traversal). 
    138138        inline osg::Vec3 transformWorldToLocal(const osg::Vec3& P); 
    139          
     139 
    140140        /// Transform a vector from world to local coordinates, discarding translation (valid only during cull traversal). 
    141141        inline osg::Vec3 rotateWorldToLocal(const osg::Vec3& P); 
    142142 
    143         virtual osg::BoundingSphere computeBound() const;     
     143        virtual osg::BoundingSphere computeBound() const; 
    144144 
    145145    protected: 
    146146        virtual ~ParticleProcessor() {} 
    147147        ParticleProcessor& operator=(const ParticleProcessor&) { return *this; } 
    148          
     148 
    149149        virtual void process(double dt) = 0; 
    150          
     150 
    151151    private: 
    152152        ReferenceFrame _rf; 
     
    163163        osg::Matrix _previous_wtl_matrix; 
    164164        osg::NodeVisitor* _current_nodevisitor; 
    165          
     165 
    166166        bool _endless; 
    167          
     167 
    168168        double _lifeTime; 
    169169        double _startTime; 
    170170        double _currentTime; 
    171171        double _resetTime; 
    172          
    173         //added- 1/17/06- bgandere@nps.edu  
     172 
     173        //added- 1/17/06- bgandere@nps.edu 
    174174        //a var to keep from doing multiple updates 
    175175        unsigned int _frameNumber; 
    176176    }; 
    177      
     177 
    178178    // INLINE FUNCTIONS 
    179      
     179 
    180180    inline ParticleProcessor::ReferenceFrame ParticleProcessor::getReferenceFrame() const 
    181181    { 
    182182        return _rf; 
    183183    } 
    184      
     184 
    185185    inline void ParticleProcessor::setReferenceFrame(ReferenceFrame rf) 
    186186    { 
    187187        _rf = rf; 
    188188    } 
    189      
     189 
    190190    inline bool ParticleProcessor::isEnabled() const 
    191191    { 
    192192        return _enabled; 
    193193    } 
    194      
     194 
    195195    inline void ParticleProcessor::setEnabled(bool v) 
    196196    { 
     
    201201        } 
    202202    } 
    203      
     203 
    204204    inline ParticleSystem* ParticleProcessor::getParticleSystem() 
    205205    { 
     
    211211        return _ps.get(); 
    212212    } 
    213      
     213 
    214214    inline void ParticleProcessor::setParticleSystem(ParticleSystem* ps) 
    215215    { 
    216216        _ps = ps; 
    217217    } 
    218     
     218 
    219219    inline void ParticleProcessor::setEndless(bool type) 
    220220    { 
    221221        _endless = type; 
    222222    } 
    223          
     223 
    224224    inline bool ParticleProcessor::isEndless() const 
    225225    { 
     
    231231        _lifeTime = t; 
    232232    } 
    233          
     233 
    234234    inline double ParticleProcessor::getLifeTime() const 
    235235    { 
    236236        return _lifeTime; 
    237237    } 
    238         
     238 
    239239    inline void ParticleProcessor::setStartTime(double t) 
    240240    { 
    241241        _startTime = t; 
    242242    } 
    243          
     243 
    244244    inline double ParticleProcessor::getStartTime() const 
    245245    { 
     
    250250        _currentTime = t; 
    251251    } 
    252          
     252 
    253253    inline double ParticleProcessor::getCurrentTime() const 
    254254    { 
    255255        return _currentTime; 
    256256    } 
    257      
     257 
    258258    inline void ParticleProcessor::setResetTime(double t) 
    259259    { 
    260260        _resetTime = t; 
    261261    } 
    262      
     262 
    263263    inline double ParticleProcessor::getResetTime() const 
    264264    { 
     
    266266    } 
    267267 
    268     inline const osg::Matrix& ParticleProcessor::getLocalToWorldMatrix()     
     268    inline const osg::Matrix& ParticleProcessor::getLocalToWorldMatrix() 
    269269    { 
    270270        if (_need_ltw_matrix) { 
     
    281281    } 
    282282 
    283     inline const osg::Matrix& ParticleProcessor::getWorldToLocalMatrix()     
     283    inline const osg::Matrix& ParticleProcessor::getWorldToLocalMatrix() 
    284284    { 
    285285        if (_need_wtl_matrix) { 
     
    295295        return _wtl_matrix; 
    296296    } 
    297      
     297 
    298298    inline const osg::Matrix& ParticleProcessor::getPreviousLocalToWorldMatrix() 
    299299    { 
     
    312312        return getLocalToWorldMatrix().preMult(P); 
    313313    } 
    314      
     314 
    315315    inline osg::Vec3 ParticleProcessor::transformWorldToLocal(const osg::Vec3& P) 
    316316    { 
     
    320320    inline osg::Vec3 ParticleProcessor::rotateLocalToWorld(const osg::Vec3& P) 
    321321    { 
    322         return getLocalToWorldMatrix().preMult(P) -  
     322        return getLocalToWorldMatrix().preMult(P) - 
    323323            getLocalToWorldMatrix().preMult(osg::Vec3(0, 0, 0)); 
    324324    } 
    325      
     325 
    326326    inline osg::Vec3 ParticleProcessor::rotateWorldToLocal(const osg::Vec3& P) 
    327327    { 
     
    329329            getWorldToLocalMatrix().preMult(osg::Vec3(0, 0, 0)); 
    330330    } 
    331      
     331 
    332332    inline bool ParticleProcessor::isAlive() const 
    333333    {