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/src/osg/Geometry.cpp

    r12434 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*/ 
     
    9393        } 
    9494    } 
    95      
     95 
    9696} 
    9797 
     
    100100    // do dirty here to keep the getGLObjectSizeHint() estimate on the ball 
    101101    dirtyDisplayList(); 
    102      
     102 
    103103    // no need to delete, all automatically handled by ref_ptr :-) 
    104104} 
     
    119119void Geometry::setVertexArray(Array* array) 
    120120{ 
    121     _vertexData.array = array;  
    122     computeFastPathsUsed();  
    123     dirtyDisplayList();  
     121    _vertexData.array = array; 
     122    computeFastPathsUsed(); 
     123    dirtyDisplayList(); 
    124124    dirtyBound(); 
    125125 
     
    129129void Geometry::setVertexIndices(IndexArray* array) 
    130130{ 
    131     _vertexData.indices = array;  
    132     computeFastPathsUsed();  
    133     dirtyDisplayList();  
     131    _vertexData.indices = array; 
     132    computeFastPathsUsed(); 
     133    dirtyDisplayList(); 
    134134    dirtyBound(); 
    135135} 
     
    137137void Geometry::setVertexData(const ArrayData& arrayData) 
    138138{ 
    139     _vertexData = arrayData;  
    140     computeFastPathsUsed();  
    141     dirtyDisplayList();  
     139    _vertexData = arrayData; 
     140    computeFastPathsUsed(); 
     141    dirtyDisplayList(); 
    142142    dirtyBound(); 
    143143 
     
    147147void Geometry::setNormalArray(Array* array) 
    148148{ 
    149     _normalData.array = array;  
    150     if (!_normalData.array.valid()) _normalData.binding=BIND_OFF;  
    151     computeFastPathsUsed();  
     149    _normalData.array = array; 
     150    if (!_normalData.array.valid()) _normalData.binding=BIND_OFF; 
     151    computeFastPathsUsed(); 
    152152    dirtyDisplayList(); 
    153153 
     
    157157void Geometry::setNormalIndices(IndexArray* array) 
    158158{ 
    159     _normalData.indices = array;  
    160     computeFastPathsUsed();  
    161     dirtyDisplayList();  
     159    _normalData.indices = array; 
     160    computeFastPathsUsed(); 
     161    dirtyDisplayList(); 
    162162} 
    163163 
    164164void Geometry::setNormalData(const ArrayData& arrayData) 
    165165{ 
    166     _normalData = arrayData;   
    167     computeFastPathsUsed();  
     166    _normalData = arrayData; 
     167    computeFastPathsUsed(); 
    168168    dirtyDisplayList(); 
    169169 
     
    174174{ 
    175175    _colorData.array = array; 
    176     if (!_colorData.array.valid()) _colorData.binding=BIND_OFF;  
    177     computeFastPathsUsed();  
     176    if (!_colorData.array.valid()) _colorData.binding=BIND_OFF; 
     177    computeFastPathsUsed(); 
    178178    dirtyDisplayList(); 
    179179 
     
    183183void Geometry::setColorIndices(IndexArray* array) 
    184184{ 
    185     _colorData.indices = array;   
    186     computeFastPathsUsed();  
    187     dirtyDisplayList();  
     185    _colorData.indices = array; 
     186    computeFastPathsUsed(); 
     187    dirtyDisplayList(); 
    188188} 
    189189 
    190190void Geometry::setColorData(const ArrayData& arrayData) 
    191191{ 
    192     _colorData = arrayData;   
    193     computeFastPathsUsed();  
     192    _colorData = arrayData; 
     193    computeFastPathsUsed(); 
    194194    dirtyDisplayList(); 
    195195 
     
    200200void Geometry::setSecondaryColorArray(Array* array) 
    201201{ 
    202     _secondaryColorData.array = array;  
    203     if (!_secondaryColorData.array.valid()) _secondaryColorData.binding=BIND_OFF;  
    204     computeFastPathsUsed();  
     202    _secondaryColorData.array = array; 
     203    if (!_secondaryColorData.array.valid()) _secondaryColorData.binding=BIND_OFF; 
     204    computeFastPathsUsed(); 
    205205    dirtyDisplayList(); 
    206206 
     
    210210void Geometry::setSecondaryColorIndices(IndexArray* array) 
    211211{ 
    212     _secondaryColorData.indices = array;  
    213     computeFastPathsUsed();  
     212    _secondaryColorData.indices = array; 
     213    computeFastPathsUsed(); 
    214214    dirtyDisplayList(); 
    215215} 
     
    217217void Geometry::setSecondaryColorData(const ArrayData& arrayData) 
    218218{ 
    219     _secondaryColorData = arrayData;  
    220     computeFastPathsUsed();  
     219    _secondaryColorData = arrayData; 
     220    computeFastPathsUsed(); 
    221221    dirtyDisplayList(); 
    222222 
     
    226226void Geometry::setFogCoordArray(Array* array) 
    227227{ 
    228     _fogCoordData.array = array;  
    229     if (!_fogCoordData.array.valid()) _fogCoordData.binding=BIND_OFF;  
    230     computeFastPathsUsed();  
    231     dirtyDisplayList();  
     228    _fogCoordData.array = array; 
     229    if (!_fogCoordData.array.valid()) _fogCoordData.binding=BIND_OFF; 
     230    computeFastPathsUsed(); 
     231    dirtyDisplayList(); 
    232232 
    233233    if (_useVertexBufferObjects && array) addVertexBufferObjectIfRequired(array); 
     
    236236void Geometry::setFogCoordIndices(IndexArray* array) 
    237237{ 
    238     _fogCoordData.indices = array;  
    239     computeFastPathsUsed();  
     238    _fogCoordData.indices = array; 
     239    computeFastPathsUsed(); 
    240240    dirtyDisplayList(); 
    241241} 
     
    243243void Geometry::setFogCoordData(const ArrayData& arrayData) 
    244244{ 
    245     _fogCoordData = arrayData;  
    246     computeFastPathsUsed();  
     245    _fogCoordData = arrayData; 
     246    computeFastPathsUsed(); 
    247247    dirtyDisplayList(); 
    248248 
     
    250250} 
    251251 
    252 void Geometry::setNormalBinding(AttributeBinding ab)  
     252void Geometry::setNormalBinding(AttributeBinding ab) 
    253253{ 
    254254    if (_normalData.binding == ab) return; 
    255      
     255 
    256256    _normalData.binding = ab; 
    257257    computeFastPathsUsed(); 
    258     dirtyDisplayList();  
     258    dirtyDisplayList(); 
    259259} 
    260260 
     
    265265    _colorData.binding = ab; 
    266266    computeFastPathsUsed(); 
    267     dirtyDisplayList();  
     267    dirtyDisplayList(); 
    268268} 
    269269 
     
    274274    _secondaryColorData.binding = ab; 
    275275    computeFastPathsUsed(); 
    276     dirtyDisplayList();  
     276    dirtyDisplayList(); 
    277277} 
    278278 
     
    283283    _fogCoordData.binding = ab; 
    284284    computeFastPathsUsed(); 
    285     dirtyDisplayList();  
     285    dirtyDisplayList(); 
    286286} 
    287287 
     
    290290    if (_texCoordList.size()<=unit) 
    291291        _texCoordList.resize(unit+1); 
    292      
     292 
    293293    _texCoordList[unit] = arrayData; 
    294294 
     
    300300    if (_texCoordList.size()<=unit) 
    301301        _texCoordList.resize(unit+1); 
    302          
     302 
    303303    return _texCoordList[unit]; 
    304304} 
     
    308308    if (_texCoordList.size()<=unit) 
    309309        return s_InvalidArrayData; 
    310          
     310 
    311311    return _texCoordList[unit]; 
    312312} 
     
    363363    if (_vertexAttribList.size()<=index) 
    364364        _vertexAttribList.resize(index+1); 
    365          
     365 
    366366    _vertexAttribList[index] = attrData; 
    367   
     367 
    368368    computeFastPathsUsed(); 
    369369    dirtyDisplayList(); 
     
    376376    if (_vertexAttribList.size()<=index) 
    377377        _vertexAttribList.resize(index+1); 
    378          
     378 
    379379    return _vertexAttribList[index]; 
    380380} 
     
    384384    if (_vertexAttribList.size()<=_vertexAttribList.size()) 
    385385        return s_InvalidArrayData; 
    386          
     386 
    387387    return _vertexAttribList[index]; 
    388388} 
     
    506506            return addPrimitiveSet(primitiveset); 
    507507        } 
    508          
     508 
    509509    } 
    510510    OSG_WARN<<"Warning: invalid index i or primitiveset passed to osg::Geometry::insertPrimitiveSet(i,primitiveset), ignoring call."<<std::endl; 
     
    544544            _primitives.erase(_primitives.begin()+i,_primitives.end()); 
    545545        } 
    546      
     546 
    547547        dirtyDisplayList(); 
    548548        dirtyBound(); 
     
    574574    else if (_secondaryColorData.binding==BIND_PER_PRIMITIVE || (_secondaryColorData.binding==BIND_PER_VERTEX && _secondaryColorData.indices.valid())) _fastPath = false; 
    575575    else if (_fogCoordData.binding==BIND_PER_PRIMITIVE || (_fogCoordData.binding==BIND_PER_VERTEX && _fogCoordData.indices.valid())) _fastPath = false; 
    576     else  
     576    else 
    577577    { 
    578578        for( unsigned int va = 0; va < _vertexAttribList.size(); ++va ) 
     
    588588                const IndexArray * idxArray = _vertexAttribList[va].indices.get(); 
    589589 
    590                 if( _vertexAttribList[va].binding==BIND_PER_VERTEX &&  
     590                if( _vertexAttribList[va].binding==BIND_PER_VERTEX && 
    591591                    array && array->getNumElements()>0 && 
    592                     idxArray && idxArray->getNumElements()>0 )  
     592                    idxArray && idxArray->getNumElements()>0 ) 
    593593                { 
    594594                    _fastPath = false; 
     
    612612                if (texcoordData.indices->getNumElements()>0) 
    613613                { 
    614                     _fastPath = false;          
     614                    _fastPath = false; 
    615615                    break; 
    616616                } 
     
    618618        } 
    619619    } 
    620      
     620 
    621621    _supportsVertexBufferObjects = _fastPath; 
    622      
     622 
    623623    //_supportsVertexBufferObjects = false; 
    624624    //_useVertexBufferObjects = false; 
     
    656656        { 
    657657            const Array* array = _vertexAttribList[index].array.get(); 
    658             if (array) totalSize += array->getTotalDataSize();            
     658            if (array) totalSize += array->getTotalDataSize(); 
    659659        } 
    660660    } 
     
    677677{ 
    678678    unsigned int startSize = arrayList.size(); 
    679      
     679 
    680680    if (_vertexData.array.valid()) arrayList.push_back(_vertexData.array.get()); 
    681681    if (_normalData.array.valid()) arrayList.push_back(_normalData.array.get()); 
     
    683683    if (_secondaryColorData.array.valid()) arrayList.push_back(_secondaryColorData.array.get()); 
    684684    if (_fogCoordData.array.valid()) arrayList.push_back(_fogCoordData.array.get()); 
    685      
     685 
    686686    for(unsigned int unit=0;unit<_texCoordList.size();++unit) 
    687687    { 
     
    702702{ 
    703703    unsigned int startSize = drawElementsList.size(); 
    704      
     704 
    705705    for(PrimitiveSetList::const_iterator itr = _primitives.begin(); 
    706706        itr != _primitives.end(); 
     
    710710        if (de) drawElementsList.push_back(de); 
    711711    } 
    712      
     712 
    713713    return drawElementsList.size()!=startSize; 
    714714} 
     
    774774{ 
    775775    // flag = true; 
    776      
     776 
    777777    // OSG_NOTICE<<"Geometry::setUseVertexBufferObjects("<<flag<<")"<<std::endl; 
    778778 
     
    780780 
    781781    Drawable::setUseVertexBufferObjects(flag); 
    782      
     782 
    783783    ArrayList arrayList; 
    784784    getArrayList(arrayList); 
     
    792792    if (_useVertexBufferObjects) 
    793793    { 
    794         if (!arrayList.empty())  
     794        if (!arrayList.empty()) 
    795795        { 
    796796 
    797797            VertexBufferObjectList vboList; 
    798              
     798 
    799799            osg::ref_ptr<osg::VertexBufferObject> vbo; 
    800800 
     
    819819        } 
    820820 
    821         if (!drawElementsList.empty())  
     821        if (!drawElementsList.empty()) 
    822822        { 
    823823            ElementBufferObjectList eboList; 
    824              
     824 
    825825            osg::ref_ptr<osg::ElementBufferObject> ebo; 
    826826 
     
    10071007    } 
    10081008#endif 
    1009      
     1009 
    10101010    if (_internalOptimizedGeometry.valid()) 
    10111011    { 
     
    10181018    bool checkForGLErrors = state.getCheckForGLErrors()==osg::State::ONCE_PER_ATTRIBUTE; 
    10191019    if (checkForGLErrors) state.checkGLErrors("start of Geometry::drawImplementation()"); 
    1020      
     1020 
    10211021    bool useFastPath = areFastPathsUsed(); 
    10221022    // useFastPath = false; 
     
    12851285{ 
    12861286    public: 
    1287      
     1287 
    12881288        AttributeFunctorArrayVisitor(Drawable::AttributeFunctor& af): 
    12891289            _af(af), 
    12901290            _type(0) {} 
    1291      
     1291 
    12921292        virtual ~AttributeFunctorArrayVisitor() {} 
    12931293 
     
    13071307        virtual void apply(Vec3dArray& array) {  if (!array.empty()) _af.apply(_type,array.size(),&(array.front())); } 
    13081308        virtual void apply(Vec4dArray& array) {  if (!array.empty()) _af.apply(_type,array.size(),&(array.front())); } 
    1309      
    1310      
     1309 
     1310 
    13111311        inline void applyArray(Drawable::AttributeType type,Array* array) 
    13121312        { 
     
    13181318        } 
    13191319 
    1320     protected:         
    1321          
     1320    protected: 
     1321 
    13221322        AttributeFunctorArrayVisitor& operator = (const AttributeFunctorArrayVisitor&) { return *this; } 
    13231323        Drawable::AttributeFunctor&   _af; 
     
    13431343    afav.applyArray(SECONDARY_COLORS,_secondaryColorData.array.get()); 
    13441344    afav.applyArray(FOG_COORDS,_fogCoordData.array.get()); 
    1345      
     1345 
    13461346    for(unsigned unit=0;unit<_texCoordList.size();++unit) 
    13471347    { 
     
    13581358{ 
    13591359    public: 
    1360      
     1360 
    13611361        ConstAttributeFunctorArrayVisitor(Drawable::ConstAttributeFunctor& af): 
    13621362            _af(af), 
    13631363            _type(0) {} 
    1364      
     1364 
    13651365        virtual ~ConstAttributeFunctorArrayVisitor() {} 
    13661366 
     
    13801380        virtual void apply(const Vec3dArray& array) {  if (!array.empty()) _af.apply(_type,array.size(),&(array.front())); } 
    13811381        virtual void apply(const Vec4dArray& array) {  if (!array.empty()) _af.apply(_type,array.size(),&(array.front())); } 
    1382      
    1383      
     1382 
     1383 
    13841384        inline void applyArray(Drawable::AttributeType type,const Array* array) 
    13851385        { 
     
    13901390            } 
    13911391        } 
    1392      
     1392 
    13931393protected: 
    13941394 
     
    14021402{ 
    14031403    ConstAttributeFunctorArrayVisitor afav(af); 
    1404      
     1404 
    14051405    if (_vertexData.array.valid()) 
    14061406    { 
     
    14471447        switch(vertices->getType()) 
    14481448        { 
    1449         case(Array::Vec2ArrayType):  
     1449        case(Array::Vec2ArrayType): 
    14501450            functor.setVertexArray(vertices->getNumElements(),static_cast<const Vec2*>(vertices->getDataPointer())); 
    14511451            break; 
    1452         case(Array::Vec3ArrayType):  
     1452        case(Array::Vec3ArrayType): 
    14531453            functor.setVertexArray(vertices->getNumElements(),static_cast<const Vec3*>(vertices->getDataPointer())); 
    14541454            break; 
    1455         case(Array::Vec4ArrayType):  
     1455        case(Array::Vec4ArrayType): 
    14561456            functor.setVertexArray(vertices->getNumElements(),static_cast<const Vec4*>(vertices->getDataPointer())); 
    14571457            break; 
    1458         case(Array::Vec2dArrayType):  
     1458        case(Array::Vec2dArrayType): 
    14591459            functor.setVertexArray(vertices->getNumElements(),static_cast<const Vec2d*>(vertices->getDataPointer())); 
    14601460            break; 
    1461         case(Array::Vec3dArrayType):  
     1461        case(Array::Vec3dArrayType): 
    14621462            functor.setVertexArray(vertices->getNumElements(),static_cast<const Vec3d*>(vertices->getDataPointer())); 
    14631463            break; 
    1464         case(Array::Vec4dArrayType):  
     1464        case(Array::Vec4dArrayType): 
    14651465            functor.setVertexArray(vertices->getNumElements(),static_cast<const Vec4d*>(vertices->getDataPointer())); 
    14661466            break; 
     
    14691469            return; 
    14701470        } 
    1471          
     1471 
    14721472        for(PrimitiveSetList::const_iterator itr=_primitives.begin(); 
    14731473            itr!=_primitives.end(); 
     
    14881488        switch(type) 
    14891489        { 
    1490         case(Array::Vec2ArrayType):  
     1490        case(Array::Vec2ArrayType): 
    14911491            vec2Array = static_cast<const Vec2*>(vertices->getDataPointer()); 
    14921492            break; 
    1493         case(Array::Vec3ArrayType):  
     1493        case(Array::Vec3ArrayType): 
    14941494            vec3Array = static_cast<const Vec3*>(vertices->getDataPointer()); 
    14951495            break; 
    1496         case(Array::Vec4ArrayType):  
     1496        case(Array::Vec4ArrayType): 
    14971497            vec4Array = static_cast<const Vec4*>(vertices->getDataPointer()); 
    14981498            break; 
    1499         case(Array::Vec2dArrayType):  
     1499        case(Array::Vec2dArrayType): 
    15001500            vec2dArray = static_cast<const Vec2d*>(vertices->getDataPointer()); 
    15011501            break; 
    1502         case(Array::Vec3dArrayType):  
     1502        case(Array::Vec3dArrayType): 
    15031503            vec3dArray = static_cast<const Vec3d*>(vertices->getDataPointer()); 
    15041504            break; 
    1505         case(Array::Vec4dArrayType):  
     1505        case(Array::Vec4dArrayType): 
    15061506            vec4dArray = static_cast<const Vec4d*>(vertices->getDataPointer()); 
    15071507            break; 
     
    15311531                        switch(type) 
    15321532                        { 
    1533                         case(Array::Vec2ArrayType):  
     1533                        case(Array::Vec2ArrayType): 
    15341534                            functor.vertex(vec2Array[_vertexData.indices->index(vindex)]); 
    15351535                            break; 
    1536                         case(Array::Vec3ArrayType):  
     1536                        case(Array::Vec3ArrayType): 
    15371537                            functor.vertex(vec3Array[_vertexData.indices->index(vindex)]); 
    15381538                            break; 
    1539                         case(Array::Vec4ArrayType):  
     1539                        case(Array::Vec4ArrayType): 
    15401540                            functor.vertex(vec4Array[_vertexData.indices->index(vindex)]); 
    15411541                            break; 
    1542                         case(Array::Vec2dArrayType):  
     1542                        case(Array::Vec2dArrayType): 
    15431543                            functor.vertex(vec2dArray[_vertexData.indices->index(vindex)]); 
    15441544                            break; 
    1545                         case(Array::Vec3dArrayType):  
     1545                        case(Array::Vec3dArrayType): 
    15461546                            functor.vertex(vec3dArray[_vertexData.indices->index(vindex)]); 
    15471547                            break; 
    1548                         case(Array::Vec4dArrayType):  
     1548                        case(Array::Vec4dArrayType): 
    15491549                            functor.vertex(vec4dArray[_vertexData.indices->index(vindex)]); 
    15501550                            break; 
     
    15741574                            switch(type) 
    15751575                            { 
    1576                             case(Array::Vec2ArrayType):  
     1576                            case(Array::Vec2ArrayType): 
    15771577                                functor.vertex(vec2Array[_vertexData.indices->index(vindex)]); 
    15781578                                break; 
    1579                             case(Array::Vec3ArrayType):  
     1579                            case(Array::Vec3ArrayType): 
    15801580                                functor.vertex(vec3Array[_vertexData.indices->index(vindex)]); 
    15811581                                break; 
    1582                             case(Array::Vec4ArrayType):  
     1582                            case(Array::Vec4ArrayType): 
    15831583                                functor.vertex(vec4Array[_vertexData.indices->index(vindex)]); 
    15841584                                break; 
    1585                             case(Array::Vec2dArrayType):  
     1585                            case(Array::Vec2dArrayType): 
    15861586                                functor.vertex(vec2dArray[_vertexData.indices->index(vindex)]); 
    15871587                                break; 
    1588                             case(Array::Vec3dArrayType):  
     1588                            case(Array::Vec3dArrayType): 
    15891589                                functor.vertex(vec3dArray[_vertexData.indices->index(vindex)]); 
    15901590                                break; 
    1591                             case(Array::Vec4dArrayType):  
     1591                            case(Array::Vec4dArrayType): 
    15921592                                functor.vertex(vec4dArray[_vertexData.indices->index(vindex)]); 
    15931593                                break; 
     
    16161616                        switch(type) 
    16171617                        { 
    1618                         case(Array::Vec2ArrayType):  
     1618                        case(Array::Vec2ArrayType): 
    16191619                            functor.vertex(vec2Array[_vertexData.indices->index(vindex)]); 
    16201620                            break; 
    1621                         case(Array::Vec3ArrayType):  
     1621                        case(Array::Vec3ArrayType): 
    16221622                            functor.vertex(vec3Array[_vertexData.indices->index(vindex)]); 
    16231623                            break; 
    1624                         case(Array::Vec4ArrayType):  
     1624                        case(Array::Vec4ArrayType): 
    16251625                            functor.vertex(vec4Array[_vertexData.indices->index(vindex)]); 
    16261626                            break; 
    1627                         case(Array::Vec2dArrayType):  
     1627                        case(Array::Vec2dArrayType): 
    16281628                            functor.vertex(vec2dArray[_vertexData.indices->index(vindex)]); 
    16291629                            break; 
    1630                         case(Array::Vec3dArrayType):  
     1630                        case(Array::Vec3dArrayType): 
    16311631                            functor.vertex(vec3dArray[_vertexData.indices->index(vindex)]); 
    16321632                            break; 
    1633                         case(Array::Vec4dArrayType):  
     1633                        case(Array::Vec4dArrayType): 
    16341634                            functor.vertex(vec4dArray[_vertexData.indices->index(vindex)]); 
    16351635                            break; 
     
    16541654                        switch(type) 
    16551655                        { 
    1656                         case(Array::Vec2ArrayType):  
     1656                        case(Array::Vec2ArrayType): 
    16571657                            functor.vertex(vec2Array[_vertexData.indices->index(vindex)]); 
    16581658                            break; 
    1659                         case(Array::Vec3ArrayType):  
     1659                        case(Array::Vec3ArrayType): 
    16601660                            functor.vertex(vec3Array[_vertexData.indices->index(vindex)]); 
    16611661                            break; 
    1662                         case(Array::Vec4ArrayType):  
     1662                        case(Array::Vec4ArrayType): 
    16631663                            functor.vertex(vec4Array[_vertexData.indices->index(vindex)]); 
    16641664                            break; 
    1665                         case(Array::Vec2dArrayType):  
     1665                        case(Array::Vec2dArrayType): 
    16661666                            functor.vertex(vec2dArray[_vertexData.indices->index(vindex)]); 
    16671667                            break; 
    1668                         case(Array::Vec3dArrayType):  
     1668                        case(Array::Vec3dArrayType): 
    16691669                            functor.vertex(vec3dArray[_vertexData.indices->index(vindex)]); 
    16701670                            break; 
    1671                         case(Array::Vec4dArrayType):  
     1671                        case(Array::Vec4dArrayType): 
    16721672                            functor.vertex(vec4dArray[_vertexData.indices->index(vindex)]); 
    16731673                            break; 
     
    16921692                        switch(type) 
    16931693                        { 
    1694                         case(Array::Vec2ArrayType):  
     1694                        case(Array::Vec2ArrayType): 
    16951695                            functor.vertex(vec2Array[_vertexData.indices->index(vindex)]); 
    16961696                            break; 
    1697                         case(Array::Vec3ArrayType):  
     1697                        case(Array::Vec3ArrayType): 
    16981698                            functor.vertex(vec3Array[_vertexData.indices->index(vindex)]); 
    16991699                            break; 
    1700                         case(Array::Vec4ArrayType):  
     1700                        case(Array::Vec4ArrayType): 
    17011701                            functor.vertex(vec4Array[_vertexData.indices->index(vindex)]); 
    17021702                            break; 
    1703                         case(Array::Vec2dArrayType):  
     1703                        case(Array::Vec2dArrayType): 
    17041704                            functor.vertex(vec2dArray[_vertexData.indices->index(vindex)]); 
    17051705                            break; 
    1706                         case(Array::Vec3dArrayType):  
     1706                        case(Array::Vec3dArrayType): 
    17071707                            functor.vertex(vec3dArray[_vertexData.indices->index(vindex)]); 
    17081708                            break; 
    1709                         case(Array::Vec4dArrayType):  
     1709                        case(Array::Vec4dArrayType): 
    17101710                            functor.vertex(vec4dArray[_vertexData.indices->index(vindex)]); 
    17111711                            break; 
     
    17441744    switch(vertices->getType()) 
    17451745    { 
    1746     case(Array::Vec2ArrayType):  
     1746    case(Array::Vec2ArrayType): 
    17471747        functor.setVertexArray(vertices->getNumElements(),static_cast<const Vec2*>(vertices->getDataPointer())); 
    17481748        break; 
    1749     case(Array::Vec3ArrayType):  
     1749    case(Array::Vec3ArrayType): 
    17501750        functor.setVertexArray(vertices->getNumElements(),static_cast<const Vec3*>(vertices->getDataPointer())); 
    17511751        break; 
    1752     case(Array::Vec4ArrayType):  
     1752    case(Array::Vec4ArrayType): 
    17531753        functor.setVertexArray(vertices->getNumElements(),static_cast<const Vec4*>(vertices->getDataPointer())); 
    17541754        break; 
    1755     case(Array::Vec2dArrayType):  
     1755    case(Array::Vec2dArrayType): 
    17561756        functor.setVertexArray(vertices->getNumElements(),static_cast<const Vec2d*>(vertices->getDataPointer())); 
    17571757        break; 
    1758     case(Array::Vec3dArrayType):  
     1758    case(Array::Vec3dArrayType): 
    17591759        functor.setVertexArray(vertices->getNumElements(),static_cast<const Vec3d*>(vertices->getDataPointer())); 
    17601760        break; 
    1761     case(Array::Vec4dArrayType):  
     1761    case(Array::Vec4dArrayType): 
    17621762        functor.setVertexArray(vertices->getNumElements(),static_cast<const Vec4d*>(vertices->getDataPointer())); 
    17631763        break; 
     
    17981798                        functor.vertex(indices->index(vindex)); 
    17991799                    } 
    1800                      
     1800 
    18011801                    functor.end(); 
    18021802                    break; 
     
    18191819                            ++vindex; 
    18201820                        } 
    1821                          
     1821 
    18221822                        functor.end(); 
    18231823 
     
    18881888 
    18891889    unsigned int totalNumberOfPrimitives = 0; 
    1890      
     1890 
    18911891    for(Geometry::PrimitiveSetList::const_iterator itr=geom.getPrimitiveSetList().begin(); 
    18921892        itr!=geom.getPrimitiveSetList().end(); 
     
    19591959            unsigned int numVertices = geom.getVertexIndices()?geom.getVertexIndices()->getNumElements(): 
    19601960                                       geom.getVertexArray()?geom.getVertexArray()->getNumElements():0; 
    1961             if (numElements!=numVertices) return false;         
     1961            if (numElements!=numVertices) return false; 
    19621962            break; 
    19631963        } 
    1964     }  
     1964    } 
    19651965    return true; 
    19661966} 
     
    19771977        // correct binding if not correct. 
    19781978        if (arrayData.binding!=osg::Geometry::BIND_OFF) 
    1979         {  
     1979        { 
    19801980            out<<"Warning: in osg::Geometry::computeCorrectBindingsAndArraySizes() "<<std::endl 
    19811981                   <<"         "<<arrayName<<" binding has been reset to BIND_OFF"<<std::endl; 
     
    19901990        // correct binding if not correct. 
    19911991        if (arrayData.binding!=osg::Geometry::BIND_OVERALL) 
    1992         {  
     1992        { 
    19931993            out<<"Warning: in osg::Geometry::computeCorrectBindingsAndArraySizes() "<<std::endl 
    19941994                   <<"         "<<arrayName<<" binding has been reset to BIND_OVERALL"<<std::endl; 
     
    20012001    unsigned int numVertices = geom.getVertexIndices()?geom.getVertexIndices()->getNumElements(): 
    20022002                               geom.getVertexArray()?geom.getVertexArray()->getNumElements():0; 
    2003      
     2003 
    20042004    if ( numVertices==0 ) 
    20052005    { 
     
    20142014        } 
    20152015    } 
    2016      
     2016 
    20172017    if (numElements==numVertices) 
    20182018    { 
     
    20292029 
    20302030 
    2031     // check to see if binding might be per primitive set     
     2031    // check to see if binding might be per primitive set 
    20322032    unsigned int numPrimitiveSets = geom.getPrimitiveSetList().size(); 
    2033      
     2033 
    20342034    if (numElements==numPrimitiveSets) 
    20352035    { 
     
    20422042        return; 
    20432043    } 
    2044      
    2045     // check to see if binding might be per primitive    
     2044 
     2045    // check to see if binding might be per primitive 
    20462046    unsigned int numPrimitives = _computeNumberOfPrimitives(geom); 
    20472047    if (numElements==numPrimitives) 
     
    20772077    } 
    20782078    arrayData.binding = osg::Geometry::BIND_OFF; 
    2079   
    2080 }         
     2079 
     2080} 
    20812081 
    20822082bool Geometry::verifyBindings(const ArrayData& arrayData) const 
     
    21272127{ 
    21282128    // if (verifyBindings()) return; 
    2129      
     2129 
    21302130    computeCorrectBindingsAndArraySizes(_normalData,"_normalData"); 
    21312131    computeCorrectBindingsAndArraySizes(_colorData,"_colorData"); 
     
    21542154            _indices(indices), 
    21552155            _targetArray(targetArray) {} 
    2156          
     2156 
    21572157        virtual ~ExpandIndexedArray() {} 
    21582158 
    2159         // Create when both of the arrays are predefined templated classes. We  
     2159        // Create when both of the arrays are predefined templated classes. We 
    21602160        // can do some optimizations in this case that aren't possible in the general 
    21612161        // case. 
     
    21682168            if (_targetArray && _targetArray->getType()==array.getType() && _targetArray!=(osg::Array*)(&array)) 
    21692169            { 
    2170                 // reuse exisiting target array  
     2170                // reuse exisiting target array 
    21712171                newArray = static_cast<T*>(_targetArray); 
    21722172                if (newArray->size()!=indices.size()) 
     
    21912191 
    21922192        // Create when one of the arrays isn't one of the predefined templated classes. The 
    2193         // template parameter is the type of the array that will get created. This is  always  
    2194         // one of the predefined classes. We could call clone to get one of the same type as  
    2195         // the input array, but the interface of the osg::Array class doesn't include a way  
     2193        // template parameter is the type of the array that will get created. This is  always 
     2194        // one of the predefined classes. We could call clone to get one of the same type as 
     2195        // the input array, but the interface of the osg::Array class doesn't include a way 
    21962196        // to set an element. 
    21972197        template <class T> 
     
    22162216        osg::Array* create_noinline(const osg::Array& array, const osg::IndexArray& indices) 
    22172217        { 
    2218             switch (array.getType())  
     2218            switch (array.getType()) 
    22192219            { 
    22202220                case(osg::Array::ByteArrayType):   return create_noinline<osg::ByteArray>(array,indices); 
     
    22402240        osg::Array* create(const TA& array, const osg::IndexArray& indices) 
    22412241        { 
    2242             // We know that indices.getType returned the same thing as TI, but  
    2243             // we need to determine whether it is really an instance of TI, or  
    2244             // perhaps another subclass of osg::Array that contains the same  
     2242            // We know that indices.getType returned the same thing as TI, but 
     2243            // we need to determine whether it is really an instance of TI, or 
     2244            // perhaps another subclass of osg::Array that contains the same 
    22452245            // type of data. 
    22462246            const TI* ba(dynamic_cast<const TI*>(&indices)); 
     
    22662266            default:                           return create_noinline(array, _indices); 
    22672267            } 
    2268              
     2268 
    22692269        } 
    22702270 
     
    23122312        if (getTexCoordIndices(ti)) hasIndices = true; 
    23132313    } 
    2314      
     2314 
    23152315    for(unsigned int vi=0;vi<getNumVertexAttribArrays();++vi) 
    23162316    { 
     
    24032403        { 
    24042404            ExpandIndexedArray eia(*(getTexCoordIndices(ti)),target.getTexCoordArray(ti)); 
    2405              
     2405 
    24062406            getTexCoordArray(ti)->accept(eia); 
    24072407 
     
    24092409            target.setTexCoordIndices(ti,0); 
    24102410        } 
    2411         else if (getTexCoordArray(ti))  
     2411        else if (getTexCoordArray(ti)) 
    24122412        { 
    24132413            if (!copyToSelf) target.setTexCoordArray(ti,getTexCoordArray(ti)); 
    24142414        } 
    24152415    } 
    2416      
     2416 
    24172417    for(unsigned int vi=0;vi<_vertexAttribList.size();++vi) 
    24182418    { 
     
    24342434{ 
    24352435    unsigned int numSharedArrays = 0; 
    2436      
     2436 
    24372437    if (getVertexArray() && getVertexArray()->referenceCount()>1) ++numSharedArrays; 
    24382438    if (getNormalArray() && getNormalArray()->referenceCount()>1) ++numSharedArrays; 
     
    24452445        if (getTexCoordArray(ti) && getTexCoordArray(ti)->referenceCount()>1) ++numSharedArrays; 
    24462446    } 
    2447      
     2447 
    24482448    for(unsigned int vi=0;vi<_vertexAttribList.size();++vi) 
    24492449    { 
     
    24752475        } 
    24762476    } 
    2477      
     2477 
    24782478    for(unsigned int vi=0;vi<_vertexAttribList.size();++vi) 
    24792479    {