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/Particle

    r11755 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*/ 
     
    4141        time (lifeTime >= 0). For each property which is defined as a range of values, a 
    4242        "current" value will be evaluated at each frame by interpolating the <I>min</I> 
    43         and <I>max</I> values so that <I>curr_value = min</I> when <I>t == 0</I>, and  
     43        and <I>max</I> values so that <I>curr_value = min</I> when <I>t == 0</I>, and 
    4444        <I>curr_value = max</I> when <I>t == lifeTime</I>. 
    4545        You may customize the interpolator objects to achieve any kind of transition. 
     
    5151        friend class ParticleSystem; 
    5252    public: 
    53          
     53 
    5454        enum 
    5555        { 
     
    6666            QUAD_TRIANGLESTRIP,    // uses GL_TRI_angleSTRIP as primitive, but each particle needs a glBegin/glEnd pair 
    6767            HEXAGON,            // may save some filling time, but uses more triangles 
    68             LINE,               // uses GL_LINES to draw line segments that point to the direction of motion    
     68            LINE,               // uses GL_LINES to draw line segments that point to the direction of motion 
    6969            USER               // uses a user-defined drawable as primitive 
    7070        }; 
    71          
     71 
    7272        Particle(); 
    7373 
    7474        /// Get the shape of the particle. 
    7575        inline Shape getShape() const; 
    76          
     76 
    7777        /// Set the shape of the particle. 
    7878        inline void setShape(Shape s); 
     
    8080        /// Get whether the particle is still alive. 
    8181        inline bool isAlive() const; 
    82          
     82 
    8383        /// Get the life time of the particle (in seconds). 
    8484        inline double getLifeTime() const; 
    85          
     85 
    8686        /// Get the age of the particle (in seconds). 
    8787        inline double getAge() const; 
    88          
     88 
    8989        /// Get the minimum and maximum values for polygon size. 
    9090        inline const rangef& getSizeRange() const; 
    91          
     91 
    9292        /// Get the minimum and maximum values for alpha. 
    9393        inline const rangef& getAlphaRange() const; 
    94          
     94 
    9595        /// Get the minimum and maximum values for color. 
    9696        inline const rangev4& getColorRange() const; 
    97          
     97 
    9898        /// Get the interpolator for computing the size of polygons. 
    9999        inline const Interpolator* getSizeInterpolator() const; 
    100          
     100 
    101101        /// Get the interpolator for computing alpha values. 
    102102        inline const Interpolator* getAlphaInterpolator() const; 
    103          
     103 
    104104        /// Get the interpolator for computing color values. 
    105105        inline const Interpolator* getColorInterpolator() const; 
     
    109109        */ 
    110110        inline float getRadius() const; 
    111          
     111 
    112112        /** Get the mass of the particle. 
    113113            For built-in operators to work correctly, remember that the mass is expressed in kg. 
    114114        */ 
    115115        inline float getMass() const; 
    116          
     116 
    117117        /// Get <CODE>1 / getMass()</CODE>. 
    118118        inline float getMassInv() const; 
    119          
     119 
    120120        /// Get the position vector. 
    121121        inline const osg::Vec3& getPosition() const; 
    122          
     122 
    123123        /**    Get the velocity vector. 
    124124            For built-in operators to work correctly, remember that velocity components are expressed 
    125125            in meters per second. 
    126126        */ 
    127         inline const osg::Vec3& getVelocity() const;         
    128          
     127        inline const osg::Vec3& getVelocity() const; 
     128 
    129129        /// Get the previous position (the position before last update). 
    130130        inline const osg::Vec3& getPreviousPosition() const; 
     
    132132        /// Get the angle vector. 
    133133        inline const osg::Vec3& getAngle() const; 
    134          
     134 
    135135        /// Get the rotational velocity vector. 
    136136        inline const osg::Vec3& getAngularVelocity() const; 
    137          
     137 
    138138        /// Get the previous angle vector. 
    139139        inline const osg::Vec3& getPreviousAngle() const; 
    140          
     140 
    141141        /// Get the current color 
    142142        inline const osg::Vec4& getCurrentColor() const { return _current_color; } 
     
    144144        /// Get the current alpha 
    145145        inline float getCurrentAlpha() const { return _current_alpha; } 
    146          
     146 
    147147        /// Get the s texture coordinate of the bottom left of the particle 
    148148        inline float getSTexCoord() const { return _s_coord; } 
     
    153153        /// Get width of texture tile 
    154154        inline int getTileS() const; 
    155          
     155 
    156156        /// Get height of texture tile 
    157157        inline int getTileT() const; 
    158          
     158 
    159159        /// Get number of texture tiles 
    160160        inline int getNumTiles() const { return _end_tile - _start_tile + 1; } 
    161          
     161 
    162162        /** Kill the particle on next update 
    163             NOTE: after calling this function, the <CODE>isAlive()</CODE> method will still  
     163            NOTE: after calling this function, the <CODE>isAlive()</CODE> method will still 
    164164            return true until the particle is updated again. 
    165165        */ 
    166166        inline void kill(); 
    167          
     167 
    168168        /// Set the life time of the particle. 
    169169        inline void setLifeTime(double t); 
    170          
     170 
    171171        /// Set the minimum and maximum values for polygon size. 
    172172        inline void setSizeRange(const rangef& r); 
    173          
     173 
    174174        /// Set the minimum and maximum values for alpha. 
    175175        inline void setAlphaRange(const rangef& r); 
    176          
     176 
    177177        /// Set the minimum and maximum values for color. 
    178178        inline void setColorRange(const rangev4& r); 
    179          
     179 
    180180        /// Set the interpolator for computing size values. 
    181181        inline void setSizeInterpolator(Interpolator* ri); 
    182          
    183         /// Set the interpolator for computing alpha values.         
     182 
     183        /// Set the interpolator for computing alpha values. 
    184184        inline void setAlphaInterpolator(Interpolator* ai); 
    185          
     185 
    186186        /// Set the interpolator for computing color values. 
    187187        inline void setColorInterpolator(Interpolator* ci); 
     
    191191        */ 
    192192        inline void setRadius(float r); 
    193          
     193 
    194194        /** Set the mass of the particle. 
    195195            For built-in operators to work correctly, remember that the mass is expressed in kg. 
    196196        */ 
    197197        inline void setMass(float m); 
    198          
    199         /// Set the position vector.         
     198 
     199        /// Set the position vector. 
    200200        inline void setPosition(const osg::Vec3& p); 
    201          
     201 
    202202        /**    Set the velocity vector. 
    203203            For built-in operators to work correctly, remember that velocity components are expressed 
     
    205205        */ 
    206206        inline void setVelocity(const osg::Vec3& v); 
    207          
     207 
    208208        /// Add a vector to the velocity vector. 
    209209        inline void addVelocity(const osg::Vec3& dv); 
    210          
     210 
    211211        /// Transform position and velocity vectors by a matrix. 
    212212        inline void transformPositionVelocity(const osg::Matrix& xform); 
     
    217217        /// Set the angle vector. 
    218218        inline void setAngle(const osg::Vec3& a); 
    219          
     219 
    220220        /** 
    221           Set the angular velocity vector.  
     221          Set the angular velocity vector. 
    222222          Components x, y and z are angles of rotation around the respective axis (in radians). 
    223223        */ 
    224224        inline void setAngularVelocity(const osg::Vec3& v); 
    225          
     225 
    226226        /// Add a vector to the angular velocity vector. 
    227227        inline void addAngularVelocity(const osg::Vec3& dv); 
    228          
     228 
    229229        /// Transform angle and angularVelocity vectors by a matrix. 
    230230        inline void transformAngleVelocity(const osg::Matrix& xform); 
    231          
     231 
    232232        /** Update the particle (don't call this method manually). 
    233233            This method is called automatically by <CODE>ParticleSystem::update()</CODE>; it 
     
    240240        /// Perform some pre-rendering tasks. Called automatically by particle systems. 
    241241        inline void beginRender(osg::GLBeginEndAdapter* gl) const; 
    242          
     242 
    243243        /// Render the particle. Called automatically by particle systems. 
    244244        void render(osg::GLBeginEndAdapter* gl, const osg::Vec3& xpos, const osg::Vec3& px, const osg::Vec3& py, float scale = 1.0f) const; 
    245          
     245 
    246246        /// Render the particle with user-defined drawable 
    247247        void render(osg::RenderInfo& renderInfo, const osg::Vec3& xpos, const osg::Vec3& xrot) const; 
    248          
     248 
    249249        /// Perform some post-rendering tasks. Called automatically by particle systems. 
    250250        inline void endRender(osg::GLBeginEndAdapter* gl) const; 
    251          
     251 
    252252        /// Get the current (interpolated) polygon size. Valid only after the first call to update(). 
    253253        inline float getCurrentSize() const; 
    254          
     254 
    255255        /// Specify how the particle texture is tiled. 
    256256        /// All tiles in the given range are sequentially displayed during the lifetime 
     
    272272        /// Get the const next particle 
    273273        inline int getNextParticle() const { return _nextParticle; } 
    274          
     274 
    275275        /// Set the depth of the particle 
    276276        inline void setDepth(double d) { _depth = d; } 
    277          
     277 
    278278        /// Get the depth of the particle 
    279279        inline double getDepth() const { return _depth; } 
    280          
     280 
    281281        /// Set the user-defined particle drawable 
    282282        inline void setDrawable(osg::Drawable* d) { _drawable = d; } 
    283          
     283 
    284284        /// Get the user-defined particle drawable 
    285285        inline osg::Drawable* getDrawable() const { return _drawable.get(); } 
    286          
     286 
    287287        /// Sorting operator 
    288288        bool operator<(const Particle &P) const { return _depth < P._depth; } 
     
    292292 
    293293    protected: 
    294      
     294 
    295295        Shape _shape; 
    296296 
     
    317317        osg::Vec3 _angul_arvel; 
    318318 
    319         double _t0;         
     319        double _t0; 
    320320 
    321321        float _alive; 
     
    324324        osg::Vec3 _base_prop;  // [0] _alive [1] _current_size [2] _current_alpha 
    325325        osg::Vec4 _current_color; 
    326          
     326 
    327327        float _s_tile; 
    328328        float _t_tile; 
     
    332332        float _s_coord; 
    333333        float _t_coord; 
    334          
     334 
    335335        // previous and next Particles are only used in ConnectedParticleSystems 
    336336        int _previousParticle; 
    337337        int _nextParticle; 
    338          
     338 
    339339        // the depth of the particle is used only when sorting is enabled 
    340340        double _depth; 
    341          
     341 
    342342        // the particle drawable is used only when USER shape is enabled 
    343343        osg::ref_ptr<osg::Drawable> _drawable; 
     
    365365        return _lifeTime; 
    366366    } 
    367      
     367 
    368368    inline double Particle::getAge() const 
    369369    { 
    370370        return _t0; 
    371371    } 
    372      
     372 
    373373    inline float Particle::getRadius() const 
    374374    { 
    375375        return _radius; 
    376376    } 
    377      
     377 
    378378    inline void Particle::setRadius(float r) 
    379379    { 
     
    420420        return _velocity; 
    421421    } 
    422      
     422 
    423423    inline const osg::Vec3& Particle::getPreviousPosition() const 
    424424    { 
     
    430430        return _angle; 
    431431    } 
    432      
     432 
    433433    inline const osg::Vec3& Particle::getAngularVelocity() const 
    434434    { 
    435435        return _angul_arvel; 
    436436    } 
    437      
     437 
    438438    inline const osg::Vec3& Particle::getPreviousAngle() const 
    439439    { 
    440440        return _prev_angle; 
    441441    } 
    442      
     442 
    443443    inline int Particle::getTileS() const 
    444444    { 
     
    450450        return (_t_tile>0.0f) ? static_cast<int>(1.0f / _t_tile) : 1; 
    451451    } 
    452      
     452 
    453453    inline void Particle::kill() 
    454454    { 
     
    511511        _velocity = osg::Matrix::transform3x3(_velocity, xform); 
    512512    } 
    513      
     513 
    514514    inline void Particle::transformPositionVelocity(const osg::Matrix& xform1, const osg::Matrix& xform2, float r) 
    515515    { 
     
    522522        _velocity = velocity1*r + velocity2*one_minus_r; 
    523523    } 
    524      
     524 
    525525    inline void Particle::setAngle(const osg::Vec3& a) 
    526526    { 
    527527        _angle = a; 
    528528    } 
    529      
     529 
    530530    inline void Particle::setAngularVelocity(const osg::Vec3& v) 
    531531    { 
    532532        _angul_arvel = v; 
    533533    } 
    534      
     534 
    535535    inline void Particle::addAngularVelocity(const osg::Vec3& dv) 
    536536    { 
    537537        _angul_arvel += dv; 
    538538    } 
    539      
     539 
    540540    inline void Particle::transformAngleVelocity(const osg::Matrix& xform) 
    541541    { 
    542542        // this should be optimized! 
    543          
     543 
    544544        osg::Vec3 a1 = _angle + _angul_arvel; 
    545          
     545 
    546546        _angle = xform.preMult(_angle); 
    547547        a1 = xform.preMult(a1); 
    548          
     548 
    549549        _angul_arvel = a1 - _angle; 
    550550    } 
    551              
     551 
    552552    inline float Particle::getMass() const 
    553553    { 
    554554        return _mass; 
    555555    } 
    556      
     556 
    557557    inline float Particle::getMassInv() const 
    558558    { 
    559559        return _massinv; 
    560560    } 
    561      
     561 
    562562    inline void Particle::setMass(float m) 
    563563    { 
     
    565565        _massinv = 1 / m; 
    566566    } 
    567      
     567 
    568568    inline void Particle::beginRender(osg::GLBeginEndAdapter* gl) const 
    569569    { 
     
    611611       _s_tile = (sTile>0) ? 1.0f / static_cast<float>(sTile) : 1.0f; 
    612612       _t_tile = (tTile>0) ? 1.0f / static_cast<float>(tTile) : 1.0f; 
    613         
     613 
    614614       if(startTile == -1) 
    615615       {