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

Ran script to remove trailing spaces and tabs

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • OpenSceneGraph/trunk/include/osgUtil/StateGraph

    r12745 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*/ 
     
    4242{ 
    4343    public: 
    44      
     44 
    4545 
    4646        typedef std::map< const osg::StateSet*, osg::ref_ptr<StateGraph> >   ChildList; 
     
    5858        ChildList                           _children; 
    5959        LeafList                            _leaves; 
    60          
     60 
    6161        mutable float                       _averageDistance; 
    6262        mutable float                       _minimumDistance; 
    63          
     63 
    6464        osg::ref_ptr<osg::Referenced>       _userData; 
    6565 
     
    8989        { 
    9090            if (_parent) _depth = _parent->_depth + 1; 
    91              
     91 
    9292            if (_parent && _parent->_dynamic) _dynamic = true; 
    9393            else _dynamic = stateset->getDataVariance()==osg::Object::DYNAMIC; 
    9494        } 
    95              
     95 
    9696        ~StateGraph() {} 
    97          
     97 
    9898        StateGraph* cloneType() const { return new StateGraph; } 
    99          
     99 
    100100        void setUserData(osg::Referenced* obj) { _userData = obj; } 
    101101        osg::Referenced* getUserData() { return _userData.get(); } 
     
    115115            return _leaves.empty() && _children.empty(); 
    116116        } 
    117          
     117 
    118118        inline bool leaves_empty() const 
    119119        { 
     
    134134                } 
    135135                _averageDistance /= (float)_leaves.size(); 
    136                  
     136 
    137137            } 
    138138            return _averageDistance; 
    139139        } 
    140          
     140 
    141141        inline float getMinimumDistance() const 
    142142        { 
     
    152152                   if ((*itr)->_depth<_minimumDistance) _minimumDistance=(*itr)->_depth; 
    153153                } 
    154                  
     154 
    155155            } 
    156156            return _minimumDistance; 
     
    171171        /** Recursively prune the StateGraph of empty children.*/ 
    172172        void prune(); 
    173          
    174          
     173 
     174 
    175175        inline StateGraph* find_or_insert(const osg::StateSet* stateset) 
    176176        { 
     
    178178            ChildList::iterator itr = _children.find(stateset); 
    179179            if (itr!=_children.end()) return itr->second.get(); 
    180              
     180 
    181181            // create a state group and insert it into the children list 
    182182            // then return the state group. 
     
    210210 
    211211                // need to pop back root render graph. 
    212                 do  
     212                do 
    213213                { 
    214214                    return_path.push_back(sg_new); 
     
    225225                return; 
    226226            } 
    227          
     227 
    228228 
    229229            // first handle the typical case which is two state groups 
     
    231231            if (sg_curr->_parent==sg_new->_parent) 
    232232            { 
    233                  
     233 
    234234                // state has changed so need to pop old state. 
    235235                if (sg_curr->getStateSet()) state.popStateSet(); 
     
    238238                return; 
    239239            } 
    240          
     240 
    241241 
    242242            // need to pop back up to the same depth as the new state group. 
     
    246246                sg_curr = sg_curr->_parent; 
    247247            } 
    248              
     248 
    249249            // use return path to trace back steps to sg_new. 
    250250            std::vector<StateGraph*> return_path; 
     
    256256                sg_new = sg_new->_parent; 
    257257            } 
    258              
     258 
    259259            // now pop back up both parent paths until they agree. 
    260260 
     
    270270                sg_new = sg_new->_parent; 
    271271            } 
    272              
     272 
    273273            for(std::vector<StateGraph*>::reverse_iterator itr=return_path.rbegin(); 
    274274                itr!=return_path.rend(); 
     
    289289                sg_curr = sg_curr->_parent; 
    290290            } 
    291              
    292         } 
    293          
     291 
     292        } 
     293 
    294294        inline static int numToPop(StateGraph* sg_curr) 
    295295        { 
     
    301301                sg_curr = sg_curr->_parent; 
    302302            } 
    303              
     303 
    304304            return numToPop; 
    305305        }