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/osgUtil/Optimizer

    r11987 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*/ 
     
    4545        inline bool isOperationPermissibleForObject(const osg::StateSet* object) const; 
    4646        inline bool isOperationPermissibleForObject(const osg::StateAttribute* object) const; 
    47         inline bool isOperationPermissibleForObject(const osg::Drawable* object) const;         
     47        inline bool isOperationPermissibleForObject(const osg::Drawable* object) const; 
    4848        inline bool isOperationPermissibleForObject(const osg::Node* object) const; 
    4949 
     
    5757  * For example of usage see examples/osgimpostor or osgviewer. 
    5858  */ 
    59    
     59 
    6060class OSGUTIL_EXPORT Optimizer 
    6161{ 
     
    118118        /** Reset internal data to initial state - the getPermissibleOptionsMap is cleared.*/ 
    119119        void reset(); 
    120          
     120 
    121121        /** Traverse the node and its subgraph with a series of optimization 
    122122          * visitors, specified by the OptimizationOptions.*/ 
     
    128128 
    129129 
    130         /** Callback for customizing what operations are permitted on objects in the scene graph.*/         
     130        /** Callback for customizing what operations are permitted on objects in the scene graph.*/ 
    131131        struct IsOperationPermissibleForObjectCallback : public osg::Referenced 
    132132        { 
     
    135135                return optimizer->isOperationPermissibleForObjectImplementation(stateset,option); 
    136136            } 
    137              
     137 
    138138            virtual bool isOperationPermissibleForObjectImplementation(const Optimizer* optimizer, const osg::StateAttribute* attribute,unsigned int option) const 
    139139            { 
    140140                return optimizer->isOperationPermissibleForObjectImplementation(attribute,option); 
    141141            } 
    142              
     142 
    143143            virtual bool isOperationPermissibleForObjectImplementation(const Optimizer* optimizer, const osg::Drawable* drawable,unsigned int option) const 
    144144            { 
    145145                return optimizer->isOperationPermissibleForObjectImplementation(drawable,option); 
    146146            } 
    147              
     147 
    148148            virtual bool isOperationPermissibleForObjectImplementation(const Optimizer* optimizer, const osg::Node* node,unsigned int option) const 
    149149            { 
    150150                return optimizer->isOperationPermissibleForObjectImplementation(node,option); 
    151151            } 
    152              
    153         }; 
    154          
    155         /** Set the callback for customizing what operations are permitted on objects in the scene graph.*/         
     152 
     153        }; 
     154 
     155        /** Set the callback for customizing what operations are permitted on objects in the scene graph.*/ 
    156156        void setIsOperationPermissibleForObjectCallback(IsOperationPermissibleForObjectCallback* callback) { _isOperationPermissibleForObjectCallback=callback; } 
    157157 
    158         /** Get the callback for customizing what operations are permitted on objects in the scene graph.*/         
     158        /** Get the callback for customizing what operations are permitted on objects in the scene graph.*/ 
    159159        IsOperationPermissibleForObjectCallback* getIsOperationPermissibleForObjectCallback() { return _isOperationPermissibleForObjectCallback.get(); } 
    160160 
    161         /** Get the callback for customizing what operations are permitted on objects in the scene graph.*/         
     161        /** Get the callback for customizing what operations are permitted on objects in the scene graph.*/ 
    162162        const IsOperationPermissibleForObjectCallback* getIsOperationPermissibleForObjectCallback() const { return _isOperationPermissibleForObjectCallback.get(); } 
    163163 
     
    167167            _permissibleOptimizationsMap[object] = options; 
    168168        } 
    169          
     169 
    170170        inline unsigned int getPermissibleOptimizationsForObject(const osg::Object* object) const 
    171171        { 
     
    180180            if (_isOperationPermissibleForObjectCallback.valid()) 
    181181                return _isOperationPermissibleForObjectCallback->isOperationPermissibleForObjectImplementation(this,object,option); 
    182             else  
    183                 return isOperationPermissibleForObjectImplementation(object,option);  
     182            else 
     183                return isOperationPermissibleForObjectImplementation(object,option); 
    184184        } 
    185185 
     
    188188            if (_isOperationPermissibleForObjectCallback.valid()) 
    189189                return _isOperationPermissibleForObjectCallback->isOperationPermissibleForObjectImplementation(this,object,option); 
    190             else  
    191                 return isOperationPermissibleForObjectImplementation(object,option);  
     190            else 
     191                return isOperationPermissibleForObjectImplementation(object,option); 
    192192        } 
    193193 
     
    196196            if (_isOperationPermissibleForObjectCallback.valid()) 
    197197                return _isOperationPermissibleForObjectCallback->isOperationPermissibleForObjectImplementation(this,object,option); 
    198             else  
    199                 return isOperationPermissibleForObjectImplementation(object,option);  
     198            else 
     199                return isOperationPermissibleForObjectImplementation(object,option); 
    200200        } 
    201201 
     
    204204            if (_isOperationPermissibleForObjectCallback.valid()) 
    205205                return _isOperationPermissibleForObjectCallback->isOperationPermissibleForObjectImplementation(this,object,option); 
    206             else  
    207                 return isOperationPermissibleForObjectImplementation(object,option);  
     206            else 
     207                return isOperationPermissibleForObjectImplementation(object,option); 
    208208        } 
    209209 
     
    212212            return (option & getPermissibleOptimizationsForObject(stateset))!=0; 
    213213        } 
    214          
     214 
    215215        bool isOperationPermissibleForObjectImplementation(const osg::StateAttribute* attribute, unsigned int option) const 
    216216        { 
     
    246246            return (option & getPermissibleOptimizationsForObject(node))!=0; 
    247247        } 
    248          
     248 
    249249    protected: 
    250250 
     
    252252 
    253253        typedef std::map<const osg::Object*,unsigned int> PermissibleOptimizationsMap; 
    254         PermissibleOptimizationsMap _permissibleOptimizationsMap;     
    255      
     254        PermissibleOptimizationsMap _permissibleOptimizationsMap; 
     255 
    256256    public: 
    257257 
    258258        /** Flatten Static Transform nodes by applying their transform to the 
    259           * geometry on the leaves of the scene graph, then removing the  
     259          * geometry on the leaves of the scene graph, then removing the 
    260260          * now redundant transforms.  Static transformed Subgraphs that have multiple 
    261261          * parental paths above them are not flattened, if you require this then 
    262           * the subgraphs have to be duplicated - for this use the  
     262          * the subgraphs have to be duplicated - for this use the 
    263263          * FlattenStaticTransformsDuplicatingSharedSubgraphsVisitor. */ 
    264264        class OSGUTIL_EXPORT FlattenStaticTransformsVisitor : public BaseOptimizerVisitor 
     
    285285                typedef std::set<osg::Node* >                       NodeSet; 
    286286                typedef std::set<osg::Transform*>                   TransformSet; 
    287                  
     287 
    288288                TransformStack  _transformStack; 
    289289                NodeSet         _excludedNodeSet; 
     
    299299          * of duplicated and flatten individually.  This results in more static transforms 
    300300          * being removed, but also means that more data is generated, and as a result may 
    301           * not always be the most appropriate flatten visitor to use.*/   
     301          * not always be the most appropriate flatten visitor to use.*/ 
    302302        class OSGUTIL_EXPORT FlattenStaticTransformsDuplicatingSharedSubgraphsVisitor : public BaseOptimizerVisitor 
    303303        { 
     
    325325        }; 
    326326 
    327         /** Combine Static Transform nodes that sit above one another.*/         
     327        /** Combine Static Transform nodes that sit above one another.*/ 
    328328        class OSGUTIL_EXPORT CombineStaticTransformsVisitor : public BaseOptimizerVisitor 
    329329        { 
     
    357357                virtual void apply(osg::Geode& geode); 
    358358                virtual void apply(osg::Group& group); 
    359                  
     359 
    360360                void removeEmptyNodes(); 
    361361 
     
    372372                RemoveRedundantNodesVisitor(Optimizer* optimizer=0): 
    373373                    BaseOptimizerVisitor(optimizer, REMOVE_REDUNDANT_NODES) {} 
    374                  
     374 
    375375                virtual void apply(osg::Group& group); 
    376376                virtual void apply(osg::Transform& transform); 
    377                  
     377 
    378378                bool isOperationPermissible(osg::Node& node); 
    379                  
     379 
    380380                void removeRedundantNodes(); 
    381381 
     
    392392                RemoveLoadedProxyNodesVisitor(Optimizer* optimizer=0): 
    393393                    BaseOptimizerVisitor(optimizer, REMOVE_LOADED_PROXY_NODES) {} 
    394                  
     394 
    395395                virtual void apply(osg::ProxyNode& group); 
    396                  
     396 
    397397                void removeRedundantNodes(); 
    398398 
     
    431431 
    432432        }; 
    433   
     433 
    434434        /** Optimize State in the scene graph by removing duplicate state, 
    435435          * replacing it with shared instances, both for StateAttributes, 
     
    451451                } 
    452452 
    453                 /** empty visitor, make it ready for next traversal.*/         
     453                /** empty visitor, make it ready for next traversal.*/ 
    454454                virtual void reset(); 
    455455 
     
    463463 
    464464                void addStateSet(osg::StateSet* stateset,osg::Object* obj); 
    465                  
     465 
    466466                inline bool optimize(osg::Object::DataVariance variance) 
    467467                { 
     
    474474                // note, one element for DYNAMIC, STATIC and UNSPECIFIED 
    475475                bool _optimize[3]; 
    476                  
     476 
    477477                StateSetMap _statesets; 
    478478 
     
    510510 
    511511                void checkGeode(osg::Geode& geode); 
    512                  
    513         }; 
    514          
     512 
     513        }; 
     514 
    515515        class OSGUTIL_EXPORT MakeFastGeometryVisitor : public BaseOptimizerVisitor 
    516516        { 
     
    524524 
    525525                void checkGeode(osg::Geode& geode); 
    526                  
    527         };         
    528          
     526 
     527        }; 
     528 
    529529        class OSGUTIL_EXPORT MergeGeometryVisitor : public BaseOptimizerVisitor 
    530530        { 
     
    540540                    _targetMaximumNumberOfVertices = num; 
    541541                } 
    542                  
     542 
    543543                unsigned int getTargetMaximumNumberOfVertices() const 
    544544                { 
     
    574574                SpatializeGroupsVisitor(Optimizer* optimizer=0): 
    575575                    BaseOptimizerVisitor(optimizer, SPATIALIZE_GROUPS) {} 
    576                  
     576 
    577577                virtual void apply(osg::Group& group); 
    578578                virtual void apply(osg::Geode& geode); 
    579                  
     579 
    580580                bool divide(unsigned int maxNumTreesPerCell=8); 
    581                  
     581 
    582582                bool divide(osg::Group* group, unsigned int maxNumTreesPerCell); 
    583583                bool divide(osg::Geode* geode, unsigned int maxNumTreesPerCell); 
    584                  
     584 
    585585                typedef std::set<osg::Group*> GroupsToDivideList; 
    586586                GroupsToDivideList _groupsToDivideList; 
     
    597597                CopySharedSubgraphsVisitor(Optimizer* optimizer=0): 
    598598                    BaseOptimizerVisitor(optimizer, COPY_SHARED_NODES) {} 
    599                  
     599 
    600600                virtual void apply(osg::Node& node); 
    601601 
    602602                void copySharedNodes(); 
    603                  
     603 
    604604                typedef std::set<osg::Node*> SharedNodeList; 
    605605                SharedNodeList _sharedNodeList; 
    606                  
     606 
    607607        }; 
    608608 
     
    621621                        _changeClientImageStorage(changeClientImageStorage), _valueClientImageStorage(valueClientImageStorage), 
    622622                        _changeAnisotropy(changeAnisotropy), _valueAnisotropy(valueAnisotropy) {} 
    623                  
     623 
    624624                virtual void apply(osg::Geode& node); 
    625625                virtual void apply(osg::Node& node); 
     
    634634 
    635635        }; 
    636          
     636 
    637637        /** Flatten MatrixTransform/Billboard pairs.*/ 
    638638        class OSGUTIL_EXPORT FlattenBillboardVisitor : public BaseOptimizerVisitor 
     
    649649                virtual void apply(osg::Billboard& billboard); 
    650650 
    651                 void process();     
     651                void process(); 
    652652 
    653653                BillboardNodePathMap _billboards; 
    654654 
    655655        }; 
    656          
     656 
    657657        /** Texture Atlas Builder creates a set of textures/images which each contain multiple images. 
    658658          * Texture Atlas' are used to make it possible to use much wider batching of data. */ 
     
    661661        public: 
    662662            TextureAtlasBuilder(); 
    663              
     663 
    664664            void reset(); 
    665              
     665 
    666666            void setMaximumAtlasSize(int width, int height); 
    667667 
    668668            int getMaximumAtlasWidth() const { return _maximumAtlasWidth; } 
    669669            int getMaximumAtlasHeight() const { return _maximumAtlasHeight; } 
    670              
     670 
    671671            void setMargin(int margin); 
    672672            int getMargin() const { return _margin; } 
     
    674674            void addSource(const osg::Image* image); 
    675675            void addSource(const osg::Texture2D* texture); 
    676              
     676 
    677677            unsigned int getNumSources() const { return _sourceList.size(); } 
    678678            const osg::Image* getSourceImage(unsigned int i) { return _sourceList[i]->_image.get(); } 
    679679            const osg::Texture2D* getSourceTexture(unsigned int i) { return _sourceList[i]->_texture.get(); } 
    680   
     680 
    681681            void buildAtlas(); 
    682682            osg::Image* getImageAtlas(unsigned int i); 
    683683            osg::Texture2D* getTextureAtlas(unsigned int i); 
    684684            osg::Matrix getTextureMatrix(unsigned int i); 
    685              
     685 
    686686            osg::Image* getImageAtlas(const osg::Image* image); 
    687687            osg::Texture2D* getTextureAtlas(const osg::Image* image); 
    688688            osg::Matrix getTextureMatrix(const osg::Image* image); 
    689              
     689 
    690690            osg::Image* getImageAtlas(const osg::Texture2D* textue); 
    691691            osg::Texture2D* getTextureAtlas(const osg::Texture2D* texture); 
    692692            osg::Matrix getTextureMatrix(const osg::Texture2D* texture); 
    693              
     693 
    694694        protected: 
    695          
     695 
    696696            int _maximumAtlasWidth; 
    697697            int _maximumAtlasHeight; 
    698698            int _margin; 
    699              
     699 
    700700 
    701701            // forward declare 
    702702            class Atlas; 
    703      
     703 
    704704            class Source : public osg::Referenced 
    705705            { 
     
    713713                Source(const osg::Texture2D* texture): 
    714714                    _x(0),_y(0),_atlas(0),_texture(texture) { if (texture) _image = texture->getImage(); } 
    715              
     715 
    716716                int _x; 
    717717                int _y; 
     
    720720                osg::ref_ptr<const osg::Image> _image; 
    721721                osg::ref_ptr<const osg::Texture2D> _texture; 
    722                  
     722 
    723723                bool suitableForAtlas(int maximumAtlasWidth, int maximumAtlasHeight, int margin); 
    724724                osg::Matrix computeTextureMatrix() const; 
    725                  
    726                  
    727             protected: 
    728              
     725 
     726 
     727            protected: 
     728 
    729729                virtual ~Source() {} 
    730730            }; 
     
    744744                    _height(0), 
    745745                    _indexFirstOfRow(0){} 
    746          
     746 
    747747                int _maximumAtlasWidth; 
    748748                int _maximumAtlasHeight; 
     
    751751                osg::ref_ptr<osg::Texture2D> _texture; 
    752752                osg::ref_ptr<osg::Image> _image; 
    753              
     753 
    754754                SourceList _sourceList; 
    755                  
     755 
    756756                int _x; 
    757757                int _y; 
     
    769769                void clampToNearestPowerOfTwoSize(); 
    770770                void copySources(); 
    771                  
     771 
    772772            protected: 
    773773                virtual ~Atlas() {} 
    774774            }; 
    775              
     775 
    776776            typedef std::vector< osg::ref_ptr<Atlas> > AtlasList; 
    777              
     777 
    778778            Source* getSource(const osg::Image* image); 
    779779            Source* getSource(const osg::Texture2D* texture); 
     
    792792        }; 
    793793 
    794   
    795         /** Optimize texture usage in the scene graph by combining textures into texture atlas  
     794 
     795        /** Optimize texture usage in the scene graph by combining textures into texture atlas 
    796796          * Use of texture atlas cuts down on the number of seperate states in the scene, reducing 
    797797          * state changes and improving the chances of use larger batches of geomertry.*/ 
     
    807807                TextureAtlasBuilder& getTextureAtlasBuilder() { return _builder; } 
    808808 
    809                 /** empty visitor, make it ready for next traversal.*/         
     809                /** empty visitor, make it ready for next traversal.*/ 
    810810                virtual void reset(); 
    811811 
     
    851851 
    852852                void applyStateSet(osg::StateSet& stateset); 
    853                  
     853 
    854854                void applyDrawable(osg::Drawable& drawable); 
    855855 
     
    859859inline bool BaseOptimizerVisitor::isOperationPermissibleForObject(const osg::StateSet* object) const 
    860860{ 
    861     return _optimizer ? _optimizer->isOperationPermissibleForObject(object,_operationType) :  true;  
     861    return _optimizer ? _optimizer->isOperationPermissibleForObject(object,_operationType) :  true; 
    862862} 
    863863 
    864864inline bool BaseOptimizerVisitor::isOperationPermissibleForObject(const osg::StateAttribute* object) const 
    865865{ 
    866     return _optimizer ? _optimizer->isOperationPermissibleForObject(object,_operationType) :  true;  
     866    return _optimizer ? _optimizer->isOperationPermissibleForObject(object,_operationType) :  true; 
    867867} 
    868868 
    869869inline bool BaseOptimizerVisitor::isOperationPermissibleForObject(const osg::Drawable* object) const 
    870870{ 
    871     return _optimizer ? _optimizer->isOperationPermissibleForObject(object,_operationType) :  true;  
     871    return _optimizer ? _optimizer->isOperationPermissibleForObject(object,_operationType) :  true; 
    872872} 
    873873 
    874874inline bool BaseOptimizerVisitor::isOperationPermissibleForObject(const osg::Node* object) const 
    875875{ 
    876     return _optimizer ? _optimizer->isOperationPermissibleForObject(object,_operationType) :  true;  
     876    return _optimizer ? _optimizer->isOperationPermissibleForObject(object,_operationType) :  true; 
    877877} 
    878878