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/src/osgUtil/Optimizer.cpp

    r13023 r13041  
    11/* -*-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*/ 
     
    6161{ 
    6262    unsigned int options = 0; 
    63      
    64      
     63 
     64 
    6565    const char* env = getenv("OSG_OPTIMIZER"); 
    6666    if (env) 
     
    117117        if(str.find("~MAKE_FAST_GEOMETRY")!=std::string::npos) options ^= MAKE_FAST_GEOMETRY; 
    118118        else if(str.find("MAKE_FAST_GEOMETRY")!=std::string::npos) options |= MAKE_FAST_GEOMETRY; 
    119          
     119 
    120120        if(str.find("~FLATTEN_BILLBOARDS")!=std::string::npos) options ^= FLATTEN_BILLBOARDS; 
    121121        else if(str.find("FLATTEN_BILLBOARDS")!=std::string::npos) options |= FLATTEN_BILLBOARDS; 
    122          
     122 
    123123        if(str.find("~TEXTURE_ATLAS_BUILDER")!=std::string::npos) options ^= TEXTURE_ATLAS_BUILDER; 
    124124        else if(str.find("TEXTURE_ATLAS_BUILDER")!=std::string::npos) options |= TEXTURE_ATLAS_BUILDER; 
    125          
     125 
    126126        if(str.find("~STATIC_OBJECT_DETECTION")!=std::string::npos) options ^= STATIC_OBJECT_DETECTION; 
    127127        else if(str.find("STATIC_OBJECT_DETECTION")!=std::string::npos) options |= STATIC_OBJECT_DETECTION; 
     
    149149{ 
    150150    StatsVisitor stats; 
    151      
     151 
    152152    if (osg::getNotifyLevel()>=osg::INFO) 
    153153    { 
     
    169169 
    170170        TessellateVisitor tsv; 
    171         node->accept(tsv);         
    172     } 
    173      
     171        node->accept(tsv); 
     172    } 
     173 
    174174    if (options & REMOVE_LOADED_PROXY_NODES) 
    175175    { 
     
    187187 
    188188        CombineLODsVisitor clv(this); 
    189         node->accept(clv);         
     189        node->accept(clv); 
    190190        clv.combineLODs(); 
    191191    } 
    192      
     192 
    193193    if (options & OPTIMIZE_TEXTURE_SETTINGS) 
    194194    { 
    195195        OSG_INFO<<"Optimizer::optimize() doing OPTIMIZE_TEXTURE_SETTINGS"<<std::endl; 
    196196 
    197         TextureVisitor tv(true,true, // unref image  
     197        TextureVisitor tv(true,true, // unref image 
    198198                          false,false, // client storage 
    199199                          false,1.0, // anisotropic filtering 
     
    214214        osv.optimize(); 
    215215    } 
    216      
     216 
    217217    if (options & TEXTURE_ATLAS_BUILDER) 
    218218    { 
    219219        OSG_INFO<<"Optimizer::optimize() doing TEXTURE_ATLAS_BUILDER"<<std::endl; 
    220          
     220 
    221221        // traverse the scene collecting textures into texture atlas. 
    222222        TextureAtlasVisitor tav(this); 
     
    233233        osv.optimize(); 
    234234    } 
    235      
     235 
    236236    if (options & COPY_SHARED_NODES) 
    237237    { 
     
    242242        cssv.copySharedNodes(); 
    243243    } 
    244      
     244 
    245245    if (options & FLATTEN_STATIC_TRANSFORMS) 
    246246    { 
     
    284284 
    285285        osg::Timer_t endTick = osg::Timer::instance()->tick(); 
    286          
     286 
    287287        OSG_INFO<<"MERGE_GEODES took "<<osg::Timer::instance()->delta_s(startTick,endTick)<<std::endl; 
    288288    } 
     
    318318        OSG_INFO<<"MERGE_GEOMETRY took "<<osg::Timer::instance()->delta_s(startTick,endTick)<<std::endl; 
    319319    } 
    320      
     320 
    321321    if (options & TRISTRIP_GEOMETRY) 
    322322    { 
     
    341341 
    342342    } 
    343      
     343 
    344344    if (options & FLATTEN_BILLBOARDS) 
    345345    { 
     
    415415 
    416416template<typename T> 
    417 struct LessDerefFunctor  
     417struct LessDerefFunctor 
    418418{ 
    419419    bool operator () (const T* lhs,const T* rhs) const 
    420420    { 
    421         return (*lhs<*rhs);  
     421        return (*lhs<*rhs); 
    422422    } 
    423423}; 
     
    427427    bool operator () (const osg::StateSet* lhs,const osg::StateSet* rhs) const 
    428428    { 
    429         return (*lhs<*rhs);  
     429        return (*lhs<*rhs); 
    430430    } 
    431431}; 
     
    445445void Optimizer::StateVisitor::apply(osg::Node& node) 
    446446{ 
    447      
     447 
    448448    osg::StateSet* ss = node.getStateSet(); 
    449     if (ss && ss->getDataVariance()==osg::Object::STATIC)  
     449    if (ss && ss->getDataVariance()==osg::Object::STATIC) 
    450450    { 
    451451        if (isOperationPermissibleForObject(&node) && 
     
    464464 
    465465    osg::StateSet* ss = geode.getStateSet(); 
    466      
    467      
     466 
     467 
    468468    if (ss && ss->getDataVariance()==osg::Object::STATIC) 
    469469    { 
     
    505505        typedef std::set<osg::StateSet*>                    StateSetSet; 
    506506        typedef std::map<osg::Uniform*,StateSetSet>         UniformToStateSetMap; 
    507          
     507 
    508508        const unsigned int NON_TEXTURE_ATTRIBUTE = 0xffffffff; 
    509          
     509 
    510510        UniformToStateSetMap  uniformToStateSetMap; 
    511511 
     
    607607            } 
    608608        } 
    609          
    610                  
     609 
     610 
    611611        if (uniformToStateSetMap.size()>=2) 
    612612        { 
     
    637637            // find the duplicates. 
    638638            UniformList::iterator first_unique_uniform = uniformList.begin(); 
    639             UniformList::iterator current_uniform = first_unique_uniform;  
     639            UniformList::iterator current_uniform = first_unique_uniform; 
    640640            ++current_uniform; 
    641641            for(; current_uniform!=uniformList.end();++current_uniform) 
     
    659659 
    660660    } 
    661      
     661 
    662662    // duplicate state attributes removed. 
    663663    // now need to look at duplicate state sets. 
     
    700700                        drawable->setStateSet(*first_unique); 
    701701                    } 
    702                     else  
     702                    else 
    703703                    { 
    704704                        osg::Node* node = dynamic_cast<osg::Node*>(obj); 
     
    713713        } 
    714714    } 
    715      
     715 
    716716} 
    717717 
     
    759759            registerWithCurrentObjects(&transform); 
    760760        } 
    761          
     761 
    762762        virtual void apply(osg::Geode& geode) 
    763763        { 
    764764            traverse(geode); 
    765765        } 
    766          
     766 
    767767        virtual void apply(osg::Billboard& geode) 
    768768        { 
    769769            traverse(geode); 
    770770        } 
    771          
     771 
    772772 
    773773        void collectDataFor(osg::Node* node) 
    774774        { 
    775775            _currentObjectList.push_back(node); 
    776              
     776 
    777777            node->accept(*this); 
    778              
     778 
    779779            _currentObjectList.pop_back(); 
    780780        } 
     
    783783        { 
    784784            _currentObjectList.push_back(billboard); 
    785              
     785 
    786786            billboard->accept(*this); 
    787              
     787 
    788788            _currentObjectList.pop_back(); 
    789789        } 
    790          
     790 
    791791        void collectDataFor(osg::Drawable* drawable) 
    792792        { 
     
    812812            const osg::Drawable* drawable = dynamic_cast<const osg::Drawable*>(object); 
    813813            if (drawable) return isOperationPermissibleForObject(drawable); 
    814              
     814 
    815815            const osg::Node* node = dynamic_cast<const osg::Node*>(object); 
    816816            if (node) return isOperationPermissibleForObject(node); 
     
    825825            return BaseOptimizerVisitor::isOperationPermissibleForObject(drawable); 
    826826        } 
    827              
     827 
    828828        inline bool isOperationPermissibleForObject(const osg::Node* node) const 
    829829        { 
     
    835835        } 
    836836 
    837     protected:         
     837    protected: 
    838838 
    839839        struct TransformStruct 
     
    877877                else 
    878878                { 
    879                     if (!_transformSet.empty())  
     879                    if (!_transformSet.empty()) 
    880880                    { 
    881881                        if (!_firstMatrix.isIdentity()) _moreThanOneMatrixRequired=true; 
     
    890890            osg::Matrix     _firstMatrix; 
    891891            TransformSet    _transformSet; 
    892         };     
     892        }; 
    893893 
    894894 
     
    914914        void disableObject(ObjectMap::iterator itr); 
    915915        void doTransform(osg::Object* obj,osg::Matrix& matrix); 
    916          
     916 
    917917        osgUtil::TransformAttributeFunctor _transformFunctor; 
    918918        TransformMap    _transformMap; 
     
    941941        osg::Matrix matrix_no_trans = matrix; 
    942942        matrix_no_trans.setTrans(0.0f,0.0f,0.0f); 
    943          
     943 
    944944        osg::Vec3 v111(1.0f,1.0f,1.0f); 
    945945        osg::Vec3 new_v111 = v111*matrix_no_trans; 
     
    948948        // move center point. 
    949949        lod->setCenter(lod->getCenter()*matrix); 
    950          
     950 
    951951        // adjust ranges to new scale. 
    952952        for(unsigned int i=0;i<lod->getNumRanges();++i) 
     
    954954            lod->setRange(i,lod->getMinRange(i)*ratio,lod->getMaxRange(i)*ratio); 
    955955        } 
    956          
     956 
    957957        lod->dirtyBound(); 
    958958        return; 
     
    964964        osg::Matrix matrix_no_trans = matrix; 
    965965        matrix_no_trans.setTrans(0.0f,0.0f,0.0f); 
    966    
     966 
    967967        osgUtil::TransformAttributeFunctor tf(matrix_no_trans); 
    968968 
     
    982982            billboard->getDrawable(i)->dirtyBound(); 
    983983        } 
    984          
     984 
    985985        billboard->dirtyBound(); 
    986986 
     
    994994    { 
    995995        return; 
    996     }     
     996    } 
    997997 
    998998    if (itr->second._canBeApplied) 
     
    10171017    { 
    10181018        return; 
    1019     }     
     1019    } 
    10201020 
    10211021    if (itr->second._canBeApplied) 
    10221022    { 
    1023      
     1023 
    10241024        // we havn't been disabled yet so we need to disable, 
    10251025        itr->second._canBeApplied = false; 
     
    10441044        osg::Object* object = oitr->first; 
    10451045        ObjectStruct& os = oitr->second; 
    1046          
     1046 
    10471047        for(ObjectStruct::TransformSet::iterator titr = os._transformSet.begin(); 
    10481048            titr != os._transformSet.end(); 
     
    10531053    } 
    10541054 
    1055     // disable all the objects which have more than one matrix associated  
    1056     // with them, and then disable all transforms which have an object associated  
     1055    // disable all the objects which have more than one matrix associated 
     1056    // with them, and then disable all transforms which have an object associated 
    10571057    // them that can't be applied, and then disable all objects which have 
    1058     // disabled transforms associated, recursing until all disabled  
     1058    // disabled transforms associated, recursing until all disabled 
    10591059    // associativity. 
    10601060    // and disable all objects that the operation is not permisable for) 
     
    11431143                    } 
    11441144                } 
    1145                  
    1146             }                 
     1145 
     1146            } 
    11471147        } 
    11481148    } 
    11491149    _objectMap.clear(); 
    11501150    _transformMap.clear(); 
    1151      
     1151 
    11521152    return transformRemoved; 
    11531153} 
     
    12471247        cltv.collectDataFor(*bitr); 
    12481248    } 
    1249      
     1249 
    12501250    cltv.setUpMaps(); 
    1251      
     1251 
    12521252    for(TransformSet::iterator titr=_transformSet.begin(); 
    12531253        titr!=_transformSet.end(); 
     
    12561256        cltv.disableTransform(*titr); 
    12571257    } 
    1258      
     1258 
    12591259 
    12601260    return cltv.removeTransforms(nodeWeCannotRemove); 
     
    12761276        _transformSet.insert(&transform); 
    12771277    } 
    1278      
     1278 
    12791279    traverse(transform); 
    12801280} 
     
    12881288        if (itr!=_transformSet.end()) _transformSet.erase(itr); 
    12891289    } 
    1290      
     1290 
    12911291    bool transformRemoved = false; 
    12921292 
     
    12961296        osg::ref_ptr<osg::MatrixTransform> transform = *_transformSet.begin(); 
    12971297        _transformSet.erase(_transformSet.begin()); 
    1298          
     1298 
    12991299        if (transform->getNumChildren()==1 && 
    13001300            transform->getChild(0)->asTransform()!=0 && 
     
    13041304            // now combine with its child. 
    13051305            osg::MatrixTransform* child = transform->getChild(0)->asTransform()->asMatrixTransform(); 
    1306              
     1306 
    13071307            osg::Matrix newMatrix = child->getMatrix()*transform->getMatrix(); 
    13081308            child->setMatrix(newMatrix); 
     
    13121312                else child->setStateSet(transform->getStateSet()); 
    13131313            } 
    1314              
     1314 
    13151315            transformRemoved = true; 
    13161316 
     
    13221322                (*pitr)->replaceChild(transform.get(),child); 
    13231323            } 
    1324              
    1325         } 
    1326          
     1324 
     1325        } 
     1326 
    13271327    } 
    13281328    return transformRemoved; 
     
    13551355    { 
    13561356        // only remove empty groups, but not empty occluders. 
    1357         if (group.getNumChildren()==0 && isOperationPermissibleForObject(&group) &&  
     1357        if (group.getNumChildren()==0 && isOperationPermissibleForObject(&group) && 
    13581358            (typeid(group)==typeid(osg::Group) || (dynamic_cast<osg::Transform*>(&group) && !dynamic_cast<osg::CameraView*>(&group)))) 
    13591359        { 
     
    13761376            ++itr) 
    13771377        { 
    1378              
     1378 
    13791379            osg::ref_ptr<osg::Node> nodeToRemove = (*itr); 
    1380              
     1380 
    13811381            // take a copy of parents list since subsequent removes will modify the original one. 
    13821382            osg::Node::ParentList parents = nodeToRemove->getParents(); 
     
    13881388                osg::Group* parent = *pitr; 
    13891389                if (!dynamic_cast<osg::Sequence*>(parent) && 
    1390                     !dynamic_cast<osg::Switch*>(parent) &&  
     1390                    !dynamic_cast<osg::Switch*>(parent) && 
    13911391                    strcmp(parent->className(),"MultiSwitch")!=0) 
    13921392                { 
     
    13941394                    if (parent->getNumChildren()==0) newEmptyGroups.insert(*pitr); 
    13951395                } 
    1396             }                 
     1396            } 
    13971397        } 
    13981398 
     
    14161416           !node.getUpdateCallback() && 
    14171417           node.getDescriptions().empty() && 
    1418            isOperationPermissibleForObject(&node);     
     1418           isOperationPermissibleForObject(&node); 
    14191419} 
    14201420 
    14211421void Optimizer::RemoveRedundantNodesVisitor::apply(osg::Group& group) 
    14221422{ 
    1423     if (group.getNumChildren()==1 &&  
     1423    if (group.getNumChildren()==1 && 
    14241424        typeid(group)==typeid(osg::Group) && 
    14251425        isOperationPermissible(group)) 
     
    14781478        { 
    14791479            OSG_WARN<<"Optimizer::RemoveRedundantNodesVisitor::removeRedundantNodes() - failed dynamic_cast"<<std::endl; 
    1480         }                                 
     1480        } 
    14811481    } 
    14821482    _redundantNodeList.clear(); 
     
    15101510        if (group.valid()) 
    15111511        { 
    1512              
     1512 
    15131513            // first check to see if data was attached to the ProxyNode that we need to keep. 
    15141514            bool keepData = false; 
     
    15241524                // create a group to store all proxy's children and data. 
    15251525                osg::ref_ptr<osg::Group> newGroup = new osg::Group(*group,osg::CopyOp::SHALLOW_COPY); 
    1526                  
     1526 
    15271527 
    15281528                // take a copy of parents list since subsequent removes will modify the original one. 
     
    15591559        { 
    15601560            OSG_WARN<<"Optimizer::RemoveLoadedProxyNodesVisitor::removeRedundantNodes() - failed dynamic_cast"<<std::endl; 
    1561         }                                 
     1561        } 
    15621562    } 
    15631563    _redundantNodeList.clear(); 
     
    15721572{ 
    15731573    if (dynamic_cast<osg::PagedLOD*>(&lod)==0) 
    1574     {     
     1574    { 
    15751575        for(unsigned int i=0;i<lod.getNumParents();++i) 
    15761576        { 
     
    16831683        if (lhs->getStateSet()<rhs->getStateSet()) return true; 
    16841684        if (rhs->getStateSet()<lhs->getStateSet()) return false; 
    1685          
     1685 
    16861686        if (rhs->getVertexIndices()) { if (!lhs->getVertexIndices()) return true; } 
    16871687        else if (lhs->getVertexIndices()) return false; 
    1688          
     1688 
    16891689        if (lhs->getNormalBinding()<rhs->getNormalBinding()) return true; 
    16901690        if (rhs->getNormalBinding()<lhs->getNormalBinding()) return false; 
     
    16951695        if (lhs->getColorBinding()<rhs->getColorBinding()) return true; 
    16961696        if (rhs->getColorBinding()<lhs->getColorBinding()) return false; 
    1697          
     1697 
    16981698        if (rhs->getColorIndices()) { if (!lhs->getColorIndices()) return true; } 
    16991699        else if (lhs->getColorIndices()) return false; 
     
    17131713        if (lhs->getNumTexCoordArrays()<rhs->getNumTexCoordArrays()) return true; 
    17141714        if (rhs->getNumTexCoordArrays()<lhs->getNumTexCoordArrays()) return false; 
    1715      
     1715 
    17161716        // therefore lhs->getNumTexCoordArrays()==rhs->getNumTexCoordArrays() 
    1717          
     1717 
    17181718        unsigned int i; 
    17191719        for(i=0;i<lhs->getNumTexCoordArrays();++i) 
    17201720        { 
    1721             if (rhs->getTexCoordArray(i))  
     1721            if (rhs->getTexCoordArray(i)) 
    17221722            { 
    17231723                if (!lhs->getTexCoordArray(i)) return true; 
     
    17281728            else if (lhs->getTexCoordIndices(i)) return false; 
    17291729        } 
    1730          
     1730 
    17311731        for(i=0;i<lhs->getNumVertexAttribArrays();++i) 
    17321732        { 
    1733             if (rhs->getVertexAttribArray(i))  
     1733            if (rhs->getVertexAttribArray(i)) 
    17341734            { 
    17351735                if (!lhs->getVertexAttribArray(i)) return true; 
     
    17401740            else if (lhs->getVertexAttribIndices(i)) return false; 
    17411741        } 
    1742          
    1743          
     1742 
     1743 
    17441744        if (lhs->getNormalBinding()==osg::Geometry::BIND_OVERALL) 
    17451745        { 
     
    17681768            } 
    17691769        } 
    1770          
     1770 
    17711771        if (lhs->getColorBinding()==osg::Geometry::BIND_OVERALL) 
    17721772        { 
     
    17921792                    break; 
    17931793            } 
    1794              
     1794 
    17951795        } 
    17961796 
     
    19011901    if (geode.getNumDrawables()>=2) 
    19021902    { 
    1903      
     1903 
    19041904        // OSG_NOTICE<<"Before "<<geode.getNumDrawables()<<std::endl; 
    1905      
     1905 
    19061906        typedef std::vector<osg::Geometry*>                         DuplicateList; 
    19071907        typedef std::map<osg::Geometry*,DuplicateList,LessGeometry> GeometryDuplicateMap; 
     
    19321932            } 
    19331933            else 
    1934             {             
     1934            { 
    19351935                standardDrawables.push_back(geode.getDrawable(i)); 
    19361936            } 
     
    20192019            unsigned int numVertices(duplicateList.front()->getVertexArray() ? duplicateList.front()->getVertexArray()->getNumElements() : 0); 
    20202020            DuplicateList::iterator eachGeom(duplicateList.begin()+1); 
    2021             // until all geometries have been checked or _targetMaximumNumberOfVertices is reached  
     2021            // until all geometries have been checked or _targetMaximumNumberOfVertices is reached 
    20222022            for (;eachGeom!=duplicateList.end(); ++eachGeom) 
    20232023            { 
     
    20502050            } 
    20512051        } 
    2052          
     2052 
    20532053        if (needToDoMerge) 
    20542054        { 
     
    20602060                keepDrawables[i] = geode.getDrawable(i); 
    20612061            } 
    2062              
     2062 
    20632063            // now clear the drawable list of the Geode so we don't have to remove items one by one (which is slow) 
    20642064            geode.removeDrawables(0, geode.getNumDrawables()); 
    2065              
     2065 
    20662066            // add back in the standard drawables which arn't possible to merge. 
    20672067            for(osg::Geode::DrawableList::iterator sitr = standardDrawables.begin(); 
     
    20712071                geode.addDrawable(sitr->get()); 
    20722072            } 
    2073                  
     2073 
    20742074            // now do the merging of geometries 
    20752075            for(MergeList::iterator mitr = mergeList.begin(); 
     
    21102110                    ++dupItr) 
    21112111                { 
    2112                  
     2112 
    21132113                    osg::Geometry* rhs = *dupItr; 
    2114                      
     2114 
    21152115                    if (lhs->getVertexArray() && lhs->getVertexArray()->getNumElements()>=_targetMaximumNumberOfVertices) 
    21162116                    { 
     
    21232123                        continue; 
    21242124                    } 
    2125                      
    2126                     if (lhs->getVertexArray() && rhs->getVertexArray() &&  
     2125 
     2126                    if (lhs->getVertexArray() && rhs->getVertexArray() && 
    21272127                        (lhs->getVertexArray()->getNumElements()+rhs->getVertexArray()->getNumElements())>=_targetMaximumNumberOfVertices) 
    21282128                    { 
    21292129                        continue; 
    21302130                    } 
    2131                      
     2131 
    21322132                    if (mergeGeometry(*lhs,*rhs)) 
    21332133                    { 
     
    21872187                geom->getFogCoordBinding()!=osg::Geometry::BIND_PER_PRIMITIVE_SET) 
    21882188            { 
    2189              
     2189 
    21902190#if 1 
    21912191                bool doneCombine = false; 
     
    21982198                    osg::PrimitiveSet* lhs = primitives[lhsNo].get(); 
    21992199                    osg::PrimitiveSet* rhs = primitives[rhsNo].get(); 
    2200   
     2200 
    22012201                    bool combine = false; 
    22022202 
     
    22112211                        case(osg::PrimitiveSet::TRIANGLES): 
    22122212                        case(osg::PrimitiveSet::QUADS): 
    2213                             combine = true;        
     2213                            combine = true; 
    22142214                            break; 
    22152215                        } 
    2216                          
     2216 
    22172217                    } 
    22182218 
    22192219                    if (combine) 
    22202220                    { 
    2221                      
     2221 
    22222222                        switch(lhs->getType()) 
    22232223                        { 
     
    22572257                } 
    22582258 
    2259     #if 1                 
     2259    #if 1 
    22602260                if (doneCombine) 
    22612261                { 
     
    22652265                    osg::Geometry::PrimitiveSetList oldPrimitives; 
    22662266                    primitives.swap(oldPrimitives); 
    2267                      
     2267 
    22682268                    // now add the active primitive sets 
    22692269                    for(osg::Geometry::PrimitiveSetList::iterator pitr = oldPrimitives.begin(); 
     
    22762276    #endif 
    22772277 
    2278 #else             
     2278#else 
    22792279 
    22802280                osg::Geometry::PrimitiveSetList& primitives = geom->getPrimitiveSetList(); 
     
    22842284                    osg::PrimitiveSet* lhs = primitives[primNo].get(); 
    22852285                    osg::PrimitiveSet* rhs = primitives[primNo+1].get(); 
    2286   
     2286 
    22872287                    bool combine = false; 
    22882288 
     
    22972297                        case(osg::PrimitiveSet::TRIANGLES): 
    22982298                        case(osg::PrimitiveSet::QUADS): 
    2299                             combine = true;        
     2299                            combine = true; 
    23002300                            break; 
    23012301                        } 
    2302                          
     2302 
    23032303                    } 
    23042304 
    23052305                    if (combine) 
    23062306                    { 
    2307                      
     2307 
    23082308                        switch(lhs->getType()) 
    23092309                        { 
     
    23572357    if (geom.getSecondaryColorArray() && geom.getSecondaryColorArray()->referenceCount()>1) return true; 
    23582358    if (geom.getFogCoordArray() && geom.getFogCoordArray()->referenceCount()>1) return true; 
    2359      
     2359 
    23602360 
    23612361    for(unsigned int unit=0;unit<geom.getNumTexCoordArrays();++unit) 
     
    23642364        if (tex && tex->referenceCount()>1) return true; 
    23652365    } 
    2366      
     2366 
    23672367    // shift the indices of the incoming primitives to account for the pre existing geometry. 
    23682368    for(osg::Geometry::PrimitiveSetList::iterator primItr=geom.getPrimitiveSetList().begin(); 
     
    23722372        if ((*primItr)->referenceCount()>1) return true; 
    23732373    } 
    2374      
    2375      
     2374 
     2375 
    23762376    return false; 
    23772377} 
     
    23872387            _lhs(0), 
    23882388            _offset(0) {} 
    2389              
    2390              
     2389 
     2390 
    23912391        /// try to merge the content of two arrays. 
    23922392        bool merge(osg::Array* lhs,osg::Array* rhs, int offset=0) 
     
    23942394            if (lhs==0 || rhs==0) return true; 
    23952395            if (lhs->getType()!=rhs->getType()) return false; 
    2396              
     2396 
    23972397            _lhs = lhs; 
    23982398            _offset = offset; 
    2399              
     2399 
    24002400            rhs->accept(*this); 
    24012401            return true; 
    24022402        } 
    2403          
     2403 
    24042404        template<typename T> 
    24052405        void _merge(T& rhs) 
    24062406        { 
    2407             T* lhs = static_cast<T*>(_lhs);  
     2407            T* lhs = static_cast<T*>(_lhs); 
    24082408            lhs->insert(lhs->end(),rhs.begin(),rhs.end()); 
    24092409        } 
    2410          
     2410 
    24112411        template<typename T> 
    24122412        void _mergeAndOffset(T& rhs) 
    24132413        { 
    2414             T* lhs = static_cast<T*>(_lhs);  
     2414            T* lhs = static_cast<T*>(_lhs); 
    24152415 
    24162416            typename T::iterator itr; 
     
    24222422            } 
    24232423        } 
    2424              
     2424 
    24252425        virtual void apply(osg::Array&) { OSG_WARN << "Warning: Optimizer's MergeArrayVisitor cannot merge Array type." << std::endl; } 
    24262426 
     
    24372437        virtual void apply(osg::Vec3Array& rhs) { _merge(rhs); } 
    24382438        virtual void apply(osg::Vec4Array& rhs) { _merge(rhs); } 
    2439          
     2439 
    24402440        virtual void apply(osg::DoubleArray& rhs) { _merge(rhs); } 
    24412441        virtual void apply(osg::Vec2dArray& rhs) { _merge(rhs); } 
    24422442        virtual void apply(osg::Vec3dArray& rhs) { _merge(rhs); } 
    24432443        virtual void apply(osg::Vec4dArray& rhs) { _merge(rhs); } 
    2444          
     2444 
    24452445        virtual void apply(osg::Vec2bArray&  rhs) { _merge(rhs); } 
    24462446        virtual void apply(osg::Vec3bArray&  rhs) { _merge(rhs); } 
    2447         virtual void apply(osg::Vec4bArray&  rhs) { _merge(rhs); }         
     2447        virtual void apply(osg::Vec4bArray&  rhs) { _merge(rhs); } 
    24482448        virtual void apply(osg::Vec2sArray& rhs) { _merge(rhs); } 
    24492449        virtual void apply(osg::Vec3sArray& rhs) { _merge(rhs); } 
     
    24552455 
    24562456    MergeArrayVisitor merger; 
    2457   
     2457 
    24582458    unsigned int base = 0; 
    2459     unsigned int vbase = lhs.getVertexArray() ? lhs.getVertexArray()->getNumElements() : 0;  
     2459    unsigned int vbase = lhs.getVertexArray() ? lhs.getVertexArray()->getNumElements() : 0; 
    24602460    if (lhs.getVertexArray() && rhs.getVertexArray()) 
    24612461    { 
     
    24722472        lhs.setVertexArray(rhs.getVertexArray()); 
    24732473    } 
    2474      
     2474 
    24752475    if (lhs.getVertexIndices() && rhs.getVertexIndices()) 
    24762476    { 
     
    24872487        lhs.setVertexIndices(rhs.getVertexIndices()); 
    24882488    } 
    2489      
    2490  
    2491     unsigned int nbase = lhs.getNormalArray() ? lhs.getNormalArray()->getNumElements() : 0;  
     2489 
     2490 
     2491    unsigned int nbase = lhs.getNormalArray() ? lhs.getNormalArray()->getNumElements() : 0; 
    24922492    if (lhs.getNormalArray() && rhs.getNormalArray() && lhs.getNormalBinding()!=osg::Geometry::BIND_OVERALL) 
    24932493    { 
     
    25162516 
    25172517 
    2518     unsigned int cbase = lhs.getColorArray() ? lhs.getColorArray()->getNumElements() : 0;  
     2518    unsigned int cbase = lhs.getColorArray() ? lhs.getColorArray()->getNumElements() : 0; 
    25192519    if (lhs.getColorArray() && rhs.getColorArray() && lhs.getColorBinding()!=osg::Geometry::BIND_OVERALL) 
    25202520    { 
     
    25282528        lhs.setColorArray(rhs.getColorArray()); 
    25292529    } 
    2530      
     2530 
    25312531    if (lhs.getColorIndices() && rhs.getColorIndices() && lhs.getColorBinding()!=osg::Geometry::BIND_OVERALL) 
    25322532    { 
     
    25422542    } 
    25432543 
    2544     unsigned int scbase = lhs.getSecondaryColorArray() ? lhs.getSecondaryColorArray()->getNumElements() : 0;  
     2544    unsigned int scbase = lhs.getSecondaryColorArray() ? lhs.getSecondaryColorArray()->getNumElements() : 0; 
    25452545    if (lhs.getSecondaryColorArray() && rhs.getSecondaryColorArray() && lhs.getSecondaryColorBinding()!=osg::Geometry::BIND_OVERALL) 
    25462546    { 
     
    25542554        lhs.setSecondaryColorArray(rhs.getSecondaryColorArray()); 
    25552555    } 
    2556      
     2556 
    25572557    if (lhs.getSecondaryColorIndices() && rhs.getSecondaryColorIndices() && lhs.getSecondaryColorBinding()!=osg::Geometry::BIND_OVERALL) 
    25582558    { 
     
    25682568    } 
    25692569 
    2570     unsigned int fcbase = lhs.getFogCoordArray() ? lhs.getFogCoordArray()->getNumElements() : 0;  
     2570    unsigned int fcbase = lhs.getFogCoordArray() ? lhs.getFogCoordArray()->getNumElements() : 0; 
    25712571    if (lhs.getFogCoordArray() && rhs.getFogCoordArray() && lhs.getFogCoordBinding()!=osg::Geometry::BIND_OVERALL) 
    25722572    { 
     
    25982598    for(unit=0;unit<lhs.getNumTexCoordArrays();++unit) 
    25992599    { 
    2600         unsigned int tcbase = lhs.getTexCoordArray(unit) ? lhs.getTexCoordArray(unit)->getNumElements() : 0;  
     2600        unsigned int tcbase = lhs.getTexCoordArray(unit) ? lhs.getTexCoordArray(unit)->getNumElements() : 0; 
    26012601        if (!merger.merge(lhs.getTexCoordArray(unit),rhs.getTexCoordArray(unit))) 
    26022602        { 
     
    26122612        } 
    26132613    } 
    2614      
     2614 
    26152615    for(unit=0;unit<lhs.getNumVertexAttribArrays();++unit) 
    26162616    { 
    2617         unsigned int vabase = lhs.getVertexAttribArray(unit) ? lhs.getVertexAttribArray(unit)->getNumElements() : 0;  
     2617        unsigned int vabase = lhs.getVertexAttribArray(unit) ? lhs.getVertexAttribArray(unit)->getNumElements() : 0; 
    26182618        if (!merger.merge(lhs.getVertexAttribArray(unit),rhs.getVertexAttribArray(unit))) 
    26192619        { 
    26202620            OSG_DEBUG << "MergeGeometry: vertex attrib array not merged. Some data may be lost." <<std::endl; 
    26212621        } 
    2622          
     2622 
    26232623        if (lhs.getVertexAttribIndices(unit) && rhs.getVertexAttribIndices(unit)) 
    26242624        { 
     
    26362636    { 
    26372637        osg::PrimitiveSet* primitive = primItr->get(); 
    2638          
     2638 
    26392639        switch(primitive->getType()) 
    26402640        { 
     
    27042704        } 
    27052705    } 
    2706      
     2706 
    27072707    for(primItr=rhs.getPrimitiveSetList().begin(); primItr!=rhs.getPrimitiveSetList().end(); ++primItr) 
    27082708    { 
     
    27122712    lhs.dirtyBound(); 
    27132713    lhs.dirtyDisplayList(); 
    2714      
     2714 
    27152715    return true; 
    27162716} 
     
    27952795        if (divide(*itr,maxNumTreesPerCell)) divided = true; 
    27962796    } 
    2797      
     2797 
    27982798    for(GeodesToDivideList::iterator geode_itr=_geodesToDivideList.begin(); 
    27992799        geode_itr!=_geodesToDivideList.end(); 
     
    28022802        if (divide(*geode_itr,maxNumTreesPerCell)) divided = true; 
    28032803    } 
    2804      
     2804 
    28052805    return divided; 
    28062806} 
     
    28092809{ 
    28102810    if (group->getNumChildren()<=maxNumTreesPerCell) return false; 
    2811      
     2811 
    28122812    // create the original box. 
    28132813    osg::BoundingBox bb; 
     
    28172817        bb.expandBy(group->getChild(i)->getBound().center()); 
    28182818    } 
    2819      
     2819 
    28202820    float radius = bb.radius(); 
    28212821    float divide_distance = radius*0.7f; 
     
    28252825 
    28262826    OSG_INFO<<"Dividing "<<group->className()<<"  num children = "<<group->getNumChildren()<<"  xAxis="<<xAxis<<"  yAxis="<<yAxis<<"   zAxis="<<zAxis<<std::endl; 
    2827      
     2827 
    28282828    if (!xAxis && !yAxis && !zAxis) 
    28292829    { 
     
    28312831        return false; 
    28322832    } 
    2833      
     2833 
    28342834    unsigned int numChildrenOnEntry = group->getNumChildren(); 
    2835      
     2835 
    28362836    typedef std::pair< osg::BoundingBox, osg::ref_ptr<osg::Group> > BoxGroupPair; 
    28372837    typedef std::vector< BoxGroupPair > Boxes; 
     
    28392839    boxes.push_back( BoxGroupPair(bb,new osg::Group) ); 
    28402840 
    2841     // divide up on each axis     
     2841    // divide up on each axis 
    28422842    if (xAxis) 
    28432843    { 
     
    28902890 
    28912891    // create the groups to drop the children into 
    2892      
     2892 
    28932893 
    28942894    // bin each child into associated bb group 
     
    29212921    //      add in the bb groups 
    29222922    //      add then the unassigned children. 
    2923      
    2924      
     2923 
     2924 
    29252925    // first removing from the original group, 
    29262926    group->removeChildren(0,group->getNumChildren()); 
    2927      
     2927 
    29282928    // add in the bb groups 
    29292929    typedef std::vector< osg::ref_ptr<osg::Group> > GroupList; 
     
    29512951        } 
    29522952    } 
    2953      
    2954      
     2953 
     2954 
    29552955    // add then the unassigned children. 
    29562956    for(NodeList::iterator nitr=unassignedList.begin(); 
     
    29702970 
    29712971    return (numChildrenOnEntry<group->getNumChildren()); 
    2972      
     2972 
    29732973} 
    29742974 
     
    29772977 
    29782978    if (geode->getNumDrawables()<=maxNumTreesPerCell) return false; 
    2979      
     2979 
    29802980    // create the original box. 
    29812981    osg::BoundingBox bb; 
     
    29852985        bb.expandBy(geode->getDrawable(i)->getBound().center()); 
    29862986    } 
    2987      
     2987 
    29882988    float radius = bb.radius(); 
    29892989    float divide_distance = radius*0.7f; 
     
    29932993 
    29942994    OSG_INFO<<"INFO "<<geode->className()<<"  num drawables = "<<geode->getNumDrawables()<<"  xAxis="<<xAxis<<"  yAxis="<<yAxis<<"   zAxis="<<zAxis<<std::endl; 
    2995      
     2995 
    29962996    if (!xAxis && !yAxis && !zAxis) 
    29972997    { 
     
    29992999        return false; 
    30003000    } 
    3001      
     3001 
    30023002    osg::Node::ParentList parents = geode->getParents(); 
    3003     if (parents.empty())  
     3003    if (parents.empty()) 
    30043004    { 
    30053005        OSG_INFO<<"  Cannot perform spatialize on root Geode, add a Group above it to allow subdivision."<<std::endl; 
     
    30163016        group->addChild(newGeode); 
    30173017    } 
    3018      
     3018 
    30193019    divide(group.get(), maxNumTreesPerCell); 
    3020      
     3020 
    30213021    // keep reference around to prevent it being deleted. 
    30223022    osg::ref_ptr<osg::Geode> keepRefGeode = geode; 
    3023      
     3023 
    30243024    for(osg::Node::ParentList::iterator itr = parents.begin(); 
    30253025        itr != parents.end(); 
     
    30283028        (*itr)->replaceChild(geode, group.get()); 
    30293029    } 
    3030      
     3030 
    30313031    return true; 
    30323032} 
     
    30603060            osg::ref_ptr<osg::Object> new_object = node->clone(osg::CopyOp::DEEP_COPY_NODES | 
    30613061                                                          osg::CopyOp::DEEP_COPY_DRAWABLES); 
    3062             // cast it to node.                                               
     3062            // cast it to node. 
    30633063            osg::Node* new_node = dynamic_cast<osg::Node*>(new_object.get()); 
    30643064 
    3065             // replace the node by new_new  
     3065            // replace the node by new_new 
    30663066            if (new_node) node->getParent(i)->replaceChild(node,new_node); 
    30673067        } 
     
    30783078void Optimizer::TextureVisitor::apply(osg::Node& node) 
    30793079{ 
    3080      
     3080 
    30813081    osg::StateSet* ss = node.getStateSet(); 
    3082     if (ss &&  
     3082    if (ss && 
    30833083        isOperationPermissibleForObject(&node) && 
    30843084        isOperationPermissibleForObject(ss)) 
     
    30953095 
    30963096    osg::StateSet* ss = geode.getStateSet(); 
    3097      
     3097 
    30983098    if (ss && isOperationPermissibleForObject(ss)) 
    30993099    { 
     
    31403140            if (is) ++numImageStreams; 
    31413141        } 
    3142          
     3142 
    31433143        if (numImageStreams==0) 
    31443144        { 
     
    31463146        } 
    31473147    } 
    3148      
     3148 
    31493149    if (_changeClientImageStorage) 
    31503150    { 
    31513151        texture.setClientStorageHint(_valueClientImageStorage); 
    31523152    } 
    3153      
     3153 
    31543154    if (_changeAnisotropy) 
    31553155    { 
     
    31963196        children[i] = group.getChild(i); 
    31973197    } 
    3198      
     3198 
    31993199    // remove all children 
    32003200    group.removeChildren(0,group.getNumChildren()); 
     
    32053205        osg::Node* child = children[i].get(); 
    32063206 
    3207         if (typeid(*child)==typeid(osg::Geode))  
     3207        if (typeid(*child)==typeid(osg::Geode)) 
    32083208        { 
    32093209            osg::Geode* geode = static_cast<osg::Geode*>(child); 
     
    32193219    // if no geodes then just return. 
    32203220    if (geodeDuplicateMap.empty()) return false; 
    3221      
     3221 
    32223222    OSG_INFO<<"mergeGeodes in group '"<<group.getName()<<"' "<<geodeDuplicateMap.size()<<std::endl; 
    3223      
     3223 
    32243224    // merge 
    32253225    for(GeodeDuplicateMap::iterator itr=geodeDuplicateMap.begin(); 
     
    32333233            // add geode back into group 
    32343234            group.addChild(lhs); 
    3235              
     3235 
    32363236            for(DuplicateList::iterator dupItr=itr->second.begin()+1; 
    32373237                dupItr!=itr->second.end(); 
     
    32853285        ++itr) 
    32863286    { 
    3287         bool mergeAcceptable = true;     
     3287        bool mergeAcceptable = true; 
    32883288 
    32893289        osg::ref_ptr<osg::Billboard> billboard = itr->first; 
     
    32923292        osg::Group* mainGroup = 0; 
    32933293        if (npl.size()>1) 
    3294         {         
     3294        { 
    32953295            for(NodePathList::iterator nitr = npl.begin(); 
    32963296                nitr != npl.end(); 
     
    33063306 
    33073307                    if (group == mainGroup && 
    3308                         np[np.size()-1]==billboard.get() &&  
     3308                        np[np.size()-1]==billboard.get() && 
    33093309                        mt && mt->getDataVariance()==osg::Object::STATIC && 
    33103310                        mt->getNumChildren()==1) 
     
    33383338            new_billboard->setAxis(billboard->getAxis()); 
    33393339            new_billboard->setStateSet(billboard->getStateSet()); 
    3340             new_billboard->setName(billboard->getName());                 
     3340            new_billboard->setName(billboard->getName()); 
    33413341 
    33423342            mainGroup->addChild(new_billboard); 
     
    34333433 
    34343434            Source * source = sitr3->get(); 
    3435             if (source->_atlas || atlas->_image->getPixelFormat() != source->_image->getPixelFormat() ||  
     3435            if (source->_atlas || atlas->_image->getPixelFormat() != source->_image->getPixelFormat() || 
    34363436                atlas->_image->getDataType() != source->_image->getDataType()) 
    34373437            { 
     
    34713471            { 
    34723472                Source * source = sitr2->get(); 
    3473                 if (source->_atlas || atlas->_image->getPixelFormat() != source->_image->getPixelFormat() ||  
     3473                if (source->_atlas || atlas->_image->getPixelFormat() != source->_image->getPixelFormat() || 
    34743474                    atlas->_image->getDataType() != source->_image->getDataType()) 
    34753475                { 
     
    35203520                ++aitr) 
    35213521            { 
    3522                 if(!(*aitr)->_image ||  
     3522                if(!(*aitr)->_image || 
    35233523                    ((*aitr)->_image->getPixelFormat() == (*sitr)->_image->getPixelFormat() && 
    35243524                    (*aitr)->_image->getPacking() == (*sitr)->_image->getPacking())) 
     
    35543554        } 
    35553555    } 
    3556      
     3556 
    35573557    // build the atlas which are suitable for use, and discard the rest. 
    35583558    AtlasList activeAtlasList; 
     
    35713571            atlas->_sourceList.clear(); 
    35723572        } 
    3573          
     3573 
    35743574        if (!(atlas->_sourceList.empty())) 
    35753575        { 
     
    36723672{ 
    36733673    if (!_image) return false; 
    3674      
     3674 
    36753675    // size too big? 
    36763676    if (_image->s()+margin*2 > maximumAtlasWidth) return false; 
    36773677    if (_image->t()+margin*2 > maximumAtlasHeight) return false; 
    3678      
     3678 
    36793679    switch(_image->getPixelFormat()) 
    36803680    { 
     
    36953695    } 
    36963696 
    3697     if ((_image->getPixelSizeInBits() % 8) != 0)  
     3697    if ((_image->getPixelSizeInBits() % 8) != 0) 
    36983698    { 
    36993699        // pixel size not byte aligned so report as not suitable to prevent other atlas code from having problems with byte boundaries. 
     
    37233723        } 
    37243724    } 
    3725      
     3725 
    37263726    return true; 
    37273727} 
     
    37433743    const osg::Image* sourceImage = source->_image.get(); 
    37443744    if (!sourceImage) return DOES_NOT_FIT_IN_ANY_ROW; 
    3745      
     3745 
    37463746    // does pixel format match? 
    37473747    if (_image.valid()) 
     
    37503750        if (_image->getDataType() != sourceImage->getDataType()) return DOES_NOT_FIT_IN_ANY_ROW; 
    37513751    } 
    3752      
     3752 
    37533753    const osg::Texture2D* sourceTexture = source->_texture.get(); 
    37543754    if (sourceTexture) 
     
    37773777        { 
    37783778 
    3779             bool sourceUsesBorder = sourceTexture->getWrap(osg::Texture2D::WRAP_S)==osg::Texture2D::CLAMP_TO_BORDER ||  
     3779            bool sourceUsesBorder = sourceTexture->getWrap(osg::Texture2D::WRAP_S)==osg::Texture2D::CLAMP_TO_BORDER || 
    37803780                                    sourceTexture->getWrap(osg::Texture2D::WRAP_T)==osg::Texture2D::CLAMP_TO_BORDER; 
    37813781 
    3782             bool atlasUsesBorder = sourceTexture->getWrap(osg::Texture2D::WRAP_S)==osg::Texture2D::CLAMP_TO_BORDER ||  
     3782            bool atlasUsesBorder = sourceTexture->getWrap(osg::Texture2D::WRAP_S)==osg::Texture2D::CLAMP_TO_BORDER || 
    37833783                                   sourceTexture->getWrap(osg::Texture2D::WRAP_T)==osg::Texture2D::CLAMP_TO_BORDER; 
    37843784 
     
    37943794                if (_texture->getBorderColor() != sourceTexture->getBorderColor()) return DOES_NOT_FIT_IN_ANY_ROW; 
    37953795            } 
    3796              
     3796 
    37973797            if (_texture->getFilter(osg::Texture2D::MIN_FILTER) != sourceTexture->getFilter(osg::Texture2D::MIN_FILTER)) 
    37983798            { 
     
    38003800                return DOES_NOT_FIT_IN_ANY_ROW; 
    38013801            } 
    3802   
     3802 
    38033803            if (_texture->getFilter(osg::Texture2D::MAG_FILTER) != sourceTexture->getFilter(osg::Texture2D::MAG_FILTER)) 
    38043804            { 
     
    38063806                return DOES_NOT_FIT_IN_ANY_ROW; 
    38073807            } 
    3808              
     3808 
    38093809            if (_texture->getMaxAnisotropy() != sourceTexture->getMaxAnisotropy()) 
    38103810            { 
     
    38123812                return DOES_NOT_FIT_IN_ANY_ROW; 
    38133813            } 
    3814              
     3814 
    38153815            if (_texture->getInternalFormat() != sourceTexture->getInternalFormat()) 
    38163816            { 
     
    38183818                return DOES_NOT_FIT_IN_ANY_ROW; 
    38193819            } 
    3820              
     3820 
    38213821            if (_texture->getShadowCompareFunc() != sourceTexture->getShadowCompareFunc()) 
    38223822            { 
     
    38243824                return DOES_NOT_FIT_IN_ANY_ROW; 
    38253825            } 
    3826                  
     3826 
    38273827            if (_texture->getShadowTextureMode() != sourceTexture->getShadowTextureMode()) 
    38283828            { 
     
    38383838        } 
    38393839    } 
    3840      
     3840 
    38413841    if (sourceImage->s() + 2*_margin > _maximumAtlasWidth) 
    38423842    { 
     
    38443844        return DOES_NOT_FIT_IN_ANY_ROW; 
    38453845    } 
    3846      
     3846 
    38473847    if (sourceImage->t() + 2*_margin > _maximumAtlasHeight) 
    38483848    { 
     
    38723872        return IN_NEXT_ROW; 
    38733873    } 
    3874      
     3874 
    38753875    // no space for the texture 
    38763876    return DOES_NOT_FIT_IN_ANY_ROW; 
     
    39033903        _texture->setWrap(osg::Texture2D::WRAP_S, sourceTexture->getWrap(osg::Texture2D::WRAP_S)); 
    39043904        _texture->setWrap(osg::Texture2D::WRAP_T, sourceTexture->getWrap(osg::Texture2D::WRAP_T)); 
    3905          
     3905 
    39063906        _texture->setBorderColor(sourceTexture->getBorderColor()); 
    39073907        _texture->setBorderWidth(0); 
    3908              
     3908 
    39093909        _texture->setFilter(osg::Texture2D::MIN_FILTER, sourceTexture->getFilter(osg::Texture2D::MIN_FILTER)); 
    39103910        _texture->setFilter(osg::Texture2D::MAG_FILTER, sourceTexture->getFilter(osg::Texture2D::MAG_FILTER)); 
     
    39323932        source->_y = _y + _margin; 
    39333933        source->_atlas = this; 
    3934          
     3934 
    39353935        // move the atlas' cursor along to the right 
    39363936        _x += sourceImage->s() + 2*_margin; 
    3937          
     3937 
    39383938        if (_x > _width) _width = _x; 
    3939          
     3939 
    39403940        int localTop = _y + sourceImage->t() + 2*_margin; 
    39413941        if ( localTop > _height) _height = localTop; 
     
    39603960        source->_y = _y + _margin; 
    39613961        source->_atlas = this; 
    3962          
     3962 
    39633963        // move the atlas' cursor along to the right 
    39643964        _x += sourceImage->s() + 2*_margin; 
     
    39863986    int h = 1; 
    39873987    while (h<_height) h *= 2; 
    3988      
     3988 
    39893989    OSG_INFO<<"Clamping "<<_width<<", "<<_height<<" to "<<w<<","<<h<<std::endl; 
    3990      
     3990 
    39913991    _width = w; 
    39923992    _height = h; 
     
    40034003                          pixelFormat, dataType, 
    40044004                          packing); 
    4005                            
     4005 
    40064006    { 
    40074007        // clear memory 
     
    40094009        unsigned char* str = _image->data(); 
    40104010        for(unsigned int i=0; i<size; ++i) *(str++) = 0; 
    4011     }         
     4011    } 
    40124012 
    40134013    OSG_INFO<<"Atlas::copySources() "<<std::endl; 
     
    40524052                } 
    40534053            } 
    4054              
     4054 
    40554055            // copy top row margin 
    40564056            y = source->_y + sourceImage->t(); 
     
    40644064                    *(destPtr++) = *(sourcePtr++); 
    40654065                } 
    4066                  
    4067             } 
    4068              
     4066 
     4067            } 
     4068 
    40694069 
    40704070 
     
    40794079                    *(destPtr++) = *(sourcePtr++); 
    40804080                } 
    4081                  
     4081 
    40824082            } 
    40834083 
     
    40964096                    } 
    40974097                } 
    4098             }             
     4098            } 
    40994099 
    41004100            // copy right column margin 
     
    41124112                    } 
    41134113                } 
    4114             }             
     4114            } 
    41154115 
    41164116            // copy top left corner margin 
     
    41784178{ 
    41794179    osg::StateSet::TextureAttributeList& tal = stateset->getTextureAttributeList(); 
    4180      
     4180 
    41814181    // if no textures ignore 
    41824182    if (tal.empty()) return false; 
    4183      
     4183 
    41844184    bool pushStateState = false; 
    41854185 
    41864186    // if already in stateset list ignore 
    4187     if (_statesetMap.count(stateset)>0)  
     4187    if (_statesetMap.count(stateset)>0) 
    41884188    { 
    41894189        pushStateState = true; 
     
    42084208        } 
    42094209    } 
    4210      
     4210 
    42114211    if (pushStateState) 
    42124212    { 
     
    42144214    } 
    42154215 
    4216      
    4217     return pushStateState;   
     4216 
     4217    return pushStateState; 
    42184218} 
    42194219 
     
    42264226{ 
    42274227    bool pushedStateState = false; 
    4228      
     4228 
    42294229    osg::StateSet* ss = node.getStateSet(); 
    4230     if (ss && ss->getDataVariance()==osg::Object::STATIC)  
     4230    if (ss && ss->getDataVariance()==osg::Object::STATIC) 
    42314231    { 
    42324232        if (isOperationPermissibleForObject(&node) && 
     
    42384238 
    42394239    traverse(node); 
    4240      
     4240 
    42414241    if (pushedStateState) popStateSet(); 
    42424242} 
     
    42474247 
    42484248    osg::StateSet* ss = geode.getStateSet(); 
    4249      
    4250      
     4249 
     4250 
    42514251    bool pushedGeodeStateState = false; 
    42524252 
     
    42754275                } 
    42764276            } 
    4277              
     4277 
    42784278            if (!_statesetStack.empty()) 
    42794279            { 
    42804280                for(StateSetStack::iterator ssitr = _statesetStack.begin(); 
    4281                     ssitr != _statesetStack.end();  
     4281                    ssitr != _statesetStack.end(); 
    42824282                    ++ssitr) 
    42834283                { 
     
    42884288            if (pushedDrawableStateState) popStateSet(); 
    42894289        } 
    4290          
    4291     } 
    4292      
     4290 
     4291    } 
     4292 
    42934293    if (pushedGeodeStateState) popStateSet(); 
    42944294} 
     
    42974297{ 
    42984298    _builder.reset(); 
    4299      
     4299 
    43004300    if (_textures.size()<2) 
    43014301    { 
     
    43264326                bool t_repeat = texture->getWrap(osg::Texture2D::WRAP_T)==osg::Texture2D::REPEAT || 
    43274327                                texture->getWrap(osg::Texture2D::WRAP_T)==osg::Texture2D::MIRROR; 
    4328                                 
     4328 
    43294329                if (s_repeat || t_repeat) 
    43304330                { 
    43314331                    texturesThatRepeat.insert(texture); 
    4332                  
     4332 
    43334333                    bool s_outOfRange = false; 
    43344334                    bool t_outOfRange = false; 
    4335    
     4335 
    43364336                    float s_min = -0.001; 
    43374337                    float s_max = 1.001; 
     
    43394339                    float t_min = -0.001; 
    43404340                    float t_max = 1.001; 
    4341                      
     4341 
    43424342                    for(Drawables::iterator ditr = drawables.begin(); 
    43434343                        ditr != drawables.end(); 
     
    43654365                            s_outOfRange = true; 
    43664366                            t_outOfRange = true; 
    4367                         }                         
     4367                        } 
    43684368                    } 
    43694369 
    4370                     if (s_outOfRange || t_outOfRange)  
    4371                     {                     
     4370                    if (s_outOfRange || t_outOfRange) 
     4371                    { 
    43724372                        texturesThatRepeatAndAreOutOfRange.insert(texture); 
    43734373                    } 
     
    43784378    } 
    43794379 
    4380     // now change any texture that repeat but all texcoords to them  
     4380    // now change any texture that repeat but all texcoords to them 
    43814381    // are in 0 to 1 range than converting the to CLAMP mode, to allow them 
    43824382    // to be used in an atlas. 
     
    44344434        } 
    44354435    } 
    4436      
     4436 
    44374437    Drawables drawablesThatHaveMultipleTexturesOnOneUnit; 
    44384438    for(DrawableStateSetMap::iterator ditr = dssm.begin(); 
     
    44754475        } 
    44764476    } 
    4477          
    4478     // remap the textures in the StateSet's  
     4477 
     4478    // remap the textures in the StateSet's 
    44794479    for(sitr = _statesetMap.begin(); 
    44804480        sitr != _statesetMap.end(); 
     
    45034503 
    45044504                    stateset->setTextureAttribute(unit, newTexture); 
    4505                      
     4505 
    45064506                    Drawables& drawables = sitr->second; 
    4507                      
     4507 
    45084508                    osg::Matrix matrix = _builder.getTextureMatrix(texture); 
    4509                      
     4509 
    45104510                    // first check to see if all drawables are ok for applying texturematrix to. 
    45114511                    bool canTexMatBeFlattenedToAllDrawables = true; 
     
    45174517                        osg::Vec2Array* texcoords = geom ? dynamic_cast<osg::Vec2Array*>(geom->getTexCoordArray(unit)) : 0; 
    45184518 
    4519                         if (!texcoords)  
     4519                        if (!texcoords) 
    45204520                        { 
    45214521                            canTexMatBeFlattenedToAllDrawables = false; 
    45224522                        } 
    4523                          
     4523 
    45244524                        if (drawablesThatHaveMultipleTexturesOnOneUnit.count(*ditr)!=0) 
    45254525                        { 
     
    45514551                            { 
    45524552                                OSG_NOTICE<<"Error, Optimizer::TextureAtlasVisitor::optimize() shouldn't ever get here..."<<std::endl; 
    4553                             }                         
     4553                            } 
    45544554                        } 
    45554555                    } 
     
    45974597 
    45984598void Optimizer::StaticObjectDetectionVisitor::applyDrawable(osg::Drawable& drawable) 
    4599 {    
    4600      
     4599{ 
     4600 
    46014601    if (drawable.getStateSet()) applyStateSet(*drawable.getStateSet()); 
    4602      
     4602 
    46034603    drawable.computeDataVariance(); 
    46044604} 
     
    46614661        _matrixStack.push_back(matrix); 
    46624662        pushed = true; 
    4663      
     4663 
    46644664        // convert this Transform to a Group 
    46654665        osg::ref_ptr<osg::Group> group = new osg::Group(dynamic_cast<osg::Group&>(transform), 
     
    47364736        { 
    47374737            transformGeode(geode); 
    4738         }     
     4738        } 
    47394739        else 
    47404740        {