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/osgTerrain/Layer

    r12139 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        /** Copy constructor using CopyOp to manage deep vs shallow copy.*/ 
    4343        Layer(const Layer&,const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY); 
    44          
     44 
    4545        META_Object(osgTerrain, Layer); 
    46          
     46 
    4747        /** Set the name of this layer. */ 
    4848        void setSetName(const std::string& setname) { setName(setname); } 
     
    6363        Locator* getLocator() { return _locator.get(); } 
    6464        const Locator* getLocator() const { return _locator.get(); } 
    65   
     65 
    6666        void setMinLevel(unsigned int minLevel) { _minLevel = minLevel; } 
    6767        unsigned int getMinLevel() const { return _minLevel; } 
     
    8888        void setDefaultValue(const osg::Vec4& value) { _defaultValue = value; } 
    8989        const osg::Vec4& getDefaultValue() const { return _defaultValue; } 
    90          
     90 
    9191 
    9292        /** Set the minification texture filter to use when a texture is associated with this layer.*/ 
     
    105105 
    106106 
    107         /** Return image associated with layer if supported. */         
     107        /** Return image associated with layer if supported. */ 
    108108        virtual osg::Image* getImage() { return 0; } 
    109109 
    110         /** Return const image associated with layer if supported. */         
     110        /** Return const image associated with layer if supported. */ 
    111111        virtual const osg::Image* getImage() const { return 0; } 
    112112 
     
    168168            ir = ndc_x - double(i); 
    169169            jr = ndc_y - double(j); 
    170         }  
     170        } 
    171171 
    172172        /** 
     
    185185            double div = 0.0f; 
    186186            float v,r; 
    187              
     187 
    188188            r = (1.0f-ir)*(1.0f-jr); 
    189             if (r>0.0 && getValue(i,j,v))  
    190             { 
    191                 value += v*r; 
    192                 div += r; 
    193             } 
    194              
     189            if (r>0.0 && getValue(i,j,v)) 
     190            { 
     191                value += v*r; 
     192                div += r; 
     193            } 
     194 
    195195            r = (ir)*(1.0f-jr); 
    196             if (r>0.0 && getValue(i+1,j,v))  
    197             { 
    198                 value += v*r; 
    199                 div += r; 
    200             } 
    201              
     196            if (r>0.0 && getValue(i+1,j,v)) 
     197            { 
     198                value += v*r; 
     199                div += r; 
     200            } 
     201 
    202202            r = (ir)*(jr); 
    203             if (r>0.0 && getValue(i+1,j+1,v))  
    204             { 
    205                 value += v*r; 
    206                 div += r; 
    207             } 
    208              
     203            if (r>0.0 && getValue(i+1,j+1,v)) 
     204            { 
     205                value += v*r; 
     206                div += r; 
     207            } 
     208 
    209209            r = (1.0f-ir)*(jr); 
    210             if (r>0.0 && getValue(i,j+1,v))  
    211             { 
    212                 value += v*r; 
    213                 div += r; 
    214             } 
    215              
     210            if (r>0.0 && getValue(i,j+1,v)) 
     211            { 
     212                value += v*r; 
     213                div += r; 
     214            } 
     215 
    216216            if (div != 0.0) 
    217217            { 
     
    305305        /** Copy constructor using CopyOp to manage deep vs shallow copy.*/ 
    306306        ImageLayer(const ImageLayer& imageLayer,const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY); 
    307          
     307 
    308308        META_Object(osgTerrain, ImageLayer); 
    309309 
     
    315315        void setImage(osg::Image* image); 
    316316 
    317         /** Return image associated with layer. */   
     317        /** Return image associated with layer. */ 
    318318        virtual osg::Image* getImage() { return _image.get(); } 
    319319 
     
    349349        /** Copy constructor using CopyOp to manage deep vs shallow copy.*/ 
    350350        ContourLayer(const ContourLayer& tfLayer,const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY); 
    351          
     351 
    352352        META_Object(osgTerrain, ContourLayer); 
    353353 
     
    358358        const osg::TransferFunction1D* getTransferFunction() const { return _tf.get(); } 
    359359 
    360         /** Return image associated with layer. */   
     360        /** Return image associated with layer. */ 
    361361        virtual osg::Image* getImage() { return _tf.valid() ? _tf->getImage() : 0; } 
    362362 
     
    393393        /** Copy constructor using CopyOp to manage deep vs shallow copy.*/ 
    394394        HeightFieldLayer(const HeightFieldLayer& hfLayer,const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY); 
    395          
     395 
    396396        META_Object(osgTerrain, HeightFieldLayer); 
    397397 
     
    435435        /** Copy constructor using CopyOp to manage deep vs shallow copy.*/ 
    436436        ProxyLayer(const ProxyLayer& proxyLayer,const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY); 
    437          
     437 
    438438        META_Object(osgTerrain, ProxyLayer); 
    439          
    440         /** Return image associated with layer if supported. */         
     439 
     440        /** Return image associated with layer if supported. */ 
    441441        virtual osg::Image* getImage() 
    442442        { 
     
    452452        /** Set the implementation layer that does the actual work.*/ 
    453453        void setImplementation(Layer* layer) { _implementation = layer; } 
    454          
     454 
    455455        /** Get the implementation layer that does the actual work.*/ 
    456456        Layer* getImplementation() { return _implementation.get(); } 
     
    464464        virtual unsigned int getNumColumns() const; 
    465465        virtual unsigned int getNumRows() const; 
    466          
     466 
    467467        virtual bool transform(float offset, float scale); 
    468468 
     
    481481 
    482482        virtual ~ProxyLayer(); 
    483          
     483 
    484484        osg::ref_ptr<Layer> _implementation; 
    485485 
     
    495495        /** Copy constructor using CopyOp to manage deep vs shallow copy.*/ 
    496496        CompositeLayer(const CompositeLayer& compositeLayer,const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY); 
    497          
     497 
    498498        META_Object(osgTerrain, CompositeLayer); 
    499499 
     
    522522        void addLayer(const std::string& compoundname); 
    523523        void addLayer(const std::string& setname, const std::string& filename); 
    524          
     524 
    525525        void addLayer(Layer* layer) { _layers.push_back(CompoundNameLayer(layer->getName(),layer->getFileName(),layer)); } 
    526526 
    527527        void removeLayer(unsigned int i) { _layers.erase(_layers.begin()+i); } 
    528          
     528 
    529529        unsigned int getNumLayers() const { return _layers.size(); } 
    530530 
     
    536536        { 
    537537            CompoundNameLayer() {} 
    538          
     538 
    539539            CompoundNameLayer(const CompoundNameLayer& cnl): 
    540540                setname(cnl.setname), 
     
    550550            { 
    551551                if (&cnl==this) return *this; 
    552                  
     552 
    553553                setname = cnl.setname; 
    554554                filename = cnl.filename; 
     
    561561            osg::ref_ptr<Layer> layer; 
    562562        }; 
    563          
     563 
    564564        typedef std::vector< CompoundNameLayer > Layers; 
    565          
     565 
    566566        Layers _layers; 
    567567}; 
     
    576576        /** Copy constructor using CopyOp to manage deep vs shallow copy.*/ 
    577577        SwitchLayer(const SwitchLayer& switchLayer,const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY); 
    578          
     578 
    579579        META_Object(osgTerrain, SwitchLayer); 
    580          
     580 
    581581        void setActiveLayer(int i) { _activeLayer = i; } 
    582582        int getActiveLayer() const { return _activeLayer; } 
    583583 
    584         /** Return image associated with layer if supported. */         
     584        /** Return image associated with layer if supported. */ 
    585585        virtual osg::Image* getImage() 
    586586        { 
    587             if (_activeLayer < 0) return 0;             
     587            if (_activeLayer < 0) return 0; 
    588588            if (_activeLayer >= static_cast<int>(getNumLayers())) return 0; 
    589             return _layers[_activeLayer].layer->getImage();             
     589            return _layers[_activeLayer].layer->getImage(); 
    590590        } 
    591591 
     
    593593        virtual const osg::Image* getImage() const 
    594594        { 
    595             if (_activeLayer < 0) return 0;             
     595            if (_activeLayer < 0) return 0; 
    596596            if (_activeLayer >= static_cast<int>(getNumLayers())) return 0; 
    597             return _layers[_activeLayer].layer->getImage();             
     597            return _layers[_activeLayer].layer->getImage(); 
    598598        } 
    599599 
     
    601601 
    602602        virtual ~SwitchLayer() {} 
    603          
     603 
    604604        int _activeLayer; 
    605605};