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

    r12480 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*/ 
     
    3737unsigned int Drawable::s_numberDeletedDrawablesInLastFrame = 0; 
    3838 
    39 // static cache of deleted display lists which can only  
     39// static cache of deleted display lists which can only 
    4040// by completely deleted once the appropriate OpenGL context 
    4141// is set.  Used osg::Drawable::deleteDisplayList(..) and flushDeletedDisplayLists(..) below. 
     
    5757        return  glGenLists( 1 ); 
    5858    } 
    59     else  
     59    else 
    6060    { 
    6161        DisplayListMap::iterator itr = dll.lower_bound(sizeHint); 
     
    6565 
    6666            ++s_numberDrawablesReusedLastInLastFrame; 
    67              
     67 
    6868            GLuint globj = itr->second; 
    6969            dll.erase(itr); 
    70              
     70 
    7171            return globj; 
    72         }  
     72        } 
    7373        else 
    7474        { 
     
    124124    } 
    125125 
    126     dll.clear();          
     126    dll.clear(); 
    127127#else 
    128128    OSG_NOTICE<<"Warning: Drawable::deleteDisplayList(..) - not supported."<<std::endl; 
     
    135135 
    136136    DisplayListMap& dll = s_deletedDisplayListCache[contextID]; 
    137     dll.clear();          
     137    dll.clear(); 
    138138} 
    139139 
     
    179179             { 
    180180                OSG_WARN<<"Error in delete"<<std::endl; 
    181              }     
     181             } 
    182182        } 
    183183        else 
     
    204204             { 
    205205                OSG_WARN<<"Error in delete"<<std::endl; 
    206              }     
     206             } 
    207207        } 
    208208    } 
    209209    elapsedTime = timer.delta_s(start_tick,timer.tick()); 
    210      
     210 
    211211    if (noDeleted!=0) OSG_INFO<<"Number display lists deleted = "<<noDeleted<<" elapsed time"<<elapsedTime<<std::endl; 
    212212 
     
    291291 
    292292    bool dynamic = false; 
    293      
     293 
    294294    if (getUpdateCallback() || 
    295295        getEventCallback() || 
    296         getCullCallback())  
     296        getCullCallback()) 
    297297    { 
    298298        dynamic = true; 
    299299    } 
    300      
     300 
    301301    setDataVariance(dynamic ? DYNAMIC : STATIC); 
    302302} 
     
    322322    // do nothing if nothing changed. 
    323323    if (_stateset==stateset) return; 
    324      
     324 
    325325    // track whether we need to account for the need to do a update or event traversal. 
    326326    int delta_update = 0; 
    327327    int delta_event = 0; 
    328328 
    329     // remove this node from the current statesets parent list  
     329    // remove this node from the current statesets parent list 
    330330    if (_stateset.valid()) 
    331331    { 
     
    334334        if (_stateset->requiresEventTraversal()) --delta_event; 
    335335    } 
    336      
     336 
    337337    // set the stateset. 
    338338    _stateset = stateset; 
    339      
     339 
    340340    // add this node to the new stateset to the parent list. 
    341341    if (_stateset.valid()) 
     
    345345        if (_stateset->requiresEventTraversal()) ++delta_event; 
    346346    } 
    347      
     347 
    348348 
    349349    // only inform parents if change occurs and drawable doesn't already have an update callback 
     
    382382    if (!_updateCallback && !_parents.empty()) 
    383383    { 
    384         // need to pass on changes to parents.         
     384        // need to pass on changes to parents. 
    385385        int delta = 0; 
    386386        if (_numChildrenRequiringUpdateTraversal>0) --delta; 
     
    394394                itr != _parents.end(); 
    395395                ++itr) 
    396             {     
     396            { 
    397397                (*itr)->setNumChildrenRequiringUpdateTraversal( (*itr)->getNumChildrenRequiringUpdateTraversal()+delta ); 
    398398            } 
     
    400400        } 
    401401    } 
    402      
     402 
    403403    // finally update this objects value. 
    404404    _numChildrenRequiringUpdateTraversal=num; 
    405      
     405 
    406406} 
    407407 
     
    417417    if (!_eventCallback && !_parents.empty()) 
    418418    { 
    419         // need to pass on changes to parents.         
     419        // need to pass on changes to parents. 
    420420        int delta = 0; 
    421421        if (_numChildrenRequiringEventTraversal>0) --delta; 
     
    429429                itr != _parents.end(); 
    430430                ++itr) 
    431             {     
     431            { 
    432432                (*itr)->setNumChildrenRequiringEventTraversal( (*itr)->getNumChildrenRequiringEventTraversal()+delta ); 
    433433            } 
     
    435435        } 
    436436    } 
    437      
     437 
    438438    // finally Event this objects value. 
    439439    _numChildrenRequiringEventTraversal=num; 
    440      
     440 
    441441} 
    442442 
     
    469469 
    470470#ifdef OSG_GL_DISPLAYLISTS_AVAILABLE 
    471     // get the contextID (user defined ID of 0 upwards) for the  
     471    // get the contextID (user defined ID of 0 upwards) for the 
    472472    // current OpenGL context. 
    473473    unsigned int contextID = renderInfo.getContextID(); 
     
    478478    // call the globj if already set otherwise compile and execute. 
    479479    if( globj != 0 ) 
    480     {    
     480    { 
    481481        glDeleteLists( globj, 1 ); 
    482482    } 
     
    487487    if (_drawCallback.valid()) 
    488488        _drawCallback->drawImplementation(renderInfo,this); 
    489     else  
     489    else 
    490490        drawImplementation(renderInfo); 
    491491 
     
    522522 
    523523    if (!_useDisplayList) return; 
    524      
     524 
    525525    if (state) 
    526526    { 
    527         // get the contextID (user defined ID of 0 upwards) for the  
     527        // get the contextID (user defined ID of 0 upwards) for the 
    528528        // current OpenGL context. 
    529529        unsigned int contextID = state->getContextID(); 
     
    537537            Drawable::deleteDisplayList(contextID,globj, getGLObjectSizeHint()); 
    538538            globj = 0; 
    539         }     
     539        } 
    540540    } 
    541541    else 
     
    562562        } 
    563563    } 
    564      
     564 
    565565    // set with new value. 
    566566    _supportsDisplayList=flag; 
     
    581581        dirtyDisplayList(); 
    582582    } 
    583      
     583 
    584584    if (_supportsDisplayList) 
    585585    { 
    586      
     586 
    587587        // set with new value. 
    588588        _useDisplayList = flag; 
    589          
     589 
    590590    } 
    591591    else // does not support display lists. 
     
    595595            OSG_WARN<<"Warning: attempt to setUseDisplayList(true) on a drawable with does not support display lists."<<std::endl; 
    596596        } 
    597         else  
     597        else 
    598598        { 
    599599            // set with new value. 
     
    644644{ 
    645645    if (_updateCallback==ac) return; 
    646      
     646 
    647647    int delta = 0; 
    648648    if (_updateCallback.valid()) --delta; 
     
    650650 
    651651    _updateCallback = ac; 
    652      
     652 
    653653    if (delta!=0 && !(_stateset.valid() && _stateset->requiresUpdateTraversal())) 
    654654    { 
     
    665665{ 
    666666    if (_eventCallback==ac) return; 
    667      
     667 
    668668    int delta = 0; 
    669669    if (_eventCallback.valid()) --delta; 
     
    671671 
    672672    _eventCallback = ac; 
    673      
     673 
    674674    if (delta!=0 && !(_stateset.valid() && _stateset->requiresEventTraversal())) 
    675675    { 
     
    688688        { 
    689689            _vertices2f = 0; 
    690             _vertices3f = 0;   
     690            _vertices3f = 0; 
    691691            _vertices4f = 0; 
    692             _vertices2d = 0;   
    693             _vertices3d = 0;   
     692            _vertices2d = 0; 
     693            _vertices3d = 0; 
    694694            _vertices4d = 0; 
    695695        } 
     
    776776        virtual void vertex(double x,double y,double z,double w) { if (w!=0.0f) _bb.expandBy(x/w,y/w,z/w); } 
    777777        virtual void end() {} 
    778         
     778 
    779779        const Vec2*     _vertices2f; 
    780780        const Vec3*     _vertices3f; 
     
    783783        const Vec3d*    _vertices3d; 
    784784        const Vec4d*    _vertices4d; 
    785         BoundingBox     _bb;  
     785        BoundingBox     _bb; 
    786786}; 
    787787 
     
    793793    non_const_this->accept(cb); 
    794794 
    795 #if 0     
     795#if 0 
    796796    OSG_NOTICE<<"computeBound() "<<cb._bb.xMin()<<", "<<cb._bb.xMax()<<", "<<std::endl; 
    797797    OSG_NOTICE<<"               "<<cb._bb.yMin()<<", "<<cb._bb.yMax()<<", "<<std::endl; 
    798798    OSG_NOTICE<<"               "<<cb._bb.zMin()<<", "<<cb._bb.zMax()<<", "<<std::endl; 
    799799#endif 
    800      
     800 
    801801    return cb._bb; 
    802802} 
     
    844844    _isTimerQuerySupported = rhs._isTimerQuerySupported; 
    845845    _isARBTimerQuerySupported = rhs._isARBTimerQuerySupported; 
    846      
     846 
    847847    _glFogCoordfv = rhs._glFogCoordfv; 
    848848    _glSecondaryColor3ubv = rhs._glSecondaryColor3ubv; 
     
    10251025    { 
    10261026        OSG_WARN<<"Error: glFogCoordfv not supported by OpenGL driver"<<std::endl; 
    1027     }     
     1027    } 
    10281028} 
    10291029 
     
    10561056    if (_glMultiTexCoord1f) 
    10571057    { 
    1058         _glMultiTexCoord1f(target,coord);  
     1058        _glMultiTexCoord1f(target,coord); 
    10591059    } 
    10601060    else 
     
    10681068    if (_glMultiTexCoord2fv) 
    10691069    { 
    1070         _glMultiTexCoord2fv(target,coord);  
     1070        _glMultiTexCoord2fv(target,coord); 
    10711071    } 
    10721072    else 
     
    10801080    if (_glMultiTexCoord3fv) 
    10811081    { 
    1082         _glMultiTexCoord3fv(target,coord);  
     1082        _glMultiTexCoord3fv(target,coord); 
    10831083    } 
    10841084    else 
     
    10921092    if (_glMultiTexCoord4fv) 
    10931093    { 
    1094         _glMultiTexCoord4fv(target,coord);  
     1094        _glMultiTexCoord4fv(target,coord); 
    10951095    } 
    10961096    else 
     
    11041104    if (_glMultiTexCoord1d) 
    11051105    { 
    1106         _glMultiTexCoord1d(target,coord);  
     1106        _glMultiTexCoord1d(target,coord); 
    11071107    } 
    11081108    else 
     
    11161116    if (_glMultiTexCoord2dv) 
    11171117    { 
    1118         _glMultiTexCoord2dv(target,coord);  
     1118        _glMultiTexCoord2dv(target,coord); 
    11191119    } 
    11201120    else 
     
    11281128    if (_glMultiTexCoord3dv) 
    11291129    { 
    1130         _glMultiTexCoord3dv(target,coord);  
     1130        _glMultiTexCoord3dv(target,coord); 
    11311131    } 
    11321132    else 
     
    11401140    if (_glMultiTexCoord4dv) 
    11411141    { 
    1142         _glMultiTexCoord4dv(target,coord);  
     1142        _glMultiTexCoord4dv(target,coord); 
    11431143    } 
    11441144    else 
     
    11521152    if (_glVertexAttrib1s) 
    11531153    { 
    1154         _glVertexAttrib1s(index,s);  
     1154        _glVertexAttrib1s(index,s); 
    11551155    } 
    11561156    else 
     
    11641164    if (_glVertexAttrib1f) 
    11651165    { 
    1166         _glVertexAttrib1f(index,f);  
     1166        _glVertexAttrib1f(index,f); 
    11671167    } 
    11681168    else 
     
    11761176    if (_glVertexAttrib1d) 
    11771177    { 
    1178         _glVertexAttrib1d(index,f);  
     1178        _glVertexAttrib1d(index,f); 
    11791179    } 
    11801180    else 
     
    11881188    if (_glVertexAttrib2fv) 
    11891189    { 
    1190         _glVertexAttrib2fv(index,v);  
     1190        _glVertexAttrib2fv(index,v); 
    11911191    } 
    11921192    else 
     
    12001200    if (_glVertexAttrib3fv) 
    12011201    { 
    1202         _glVertexAttrib3fv(index,v);  
     1202        _glVertexAttrib3fv(index,v); 
    12031203    } 
    12041204    else 
     
    12121212    if (_glVertexAttrib4fv) 
    12131213    { 
    1214         _glVertexAttrib4fv(index,v);  
     1214        _glVertexAttrib4fv(index,v); 
    12151215    } 
    12161216    else 
     
    12241224    if (_glVertexAttrib2dv) 
    12251225    { 
    1226         _glVertexAttrib2dv(index,v);  
     1226        _glVertexAttrib2dv(index,v); 
    12271227    } 
    12281228    else 
     
    12361236    if (_glVertexAttrib3dv) 
    12371237    { 
    1238         _glVertexAttrib3dv(index,v);  
     1238        _glVertexAttrib3dv(index,v); 
    12391239    } 
    12401240    else 
     
    12481248    if (_glVertexAttrib4dv) 
    12491249    { 
    1250         _glVertexAttrib4dv(index,v);  
     1250        _glVertexAttrib4dv(index,v); 
    12511251    } 
    12521252    else 
     
    12601260    if (_glVertexAttrib4ubv) 
    12611261    { 
    1262         _glVertexAttrib4ubv(index,v);  
     1262        _glVertexAttrib4ubv(index,v); 
    12631263    } 
    12641264    else 
     
    12721272    if (_glVertexAttrib4Nubv) 
    12731273    { 
    1274         _glVertexAttrib4Nubv(index,v);  
     1274        _glVertexAttrib4Nubv(index,v); 
    12751275    } 
    12761276    else 
     
    12821282void Drawable::Extensions::glGenBuffers(GLsizei n, GLuint *buffers) const 
    12831283{ 
    1284     if (_glGenBuffers) _glGenBuffers(n, buffers);  
     1284    if (_glGenBuffers) _glGenBuffers(n, buffers); 
    12851285    else OSG_WARN<<"Error: glGenBuffers not supported by OpenGL driver"<<std::endl; 
    12861286} 
     
    12881288void Drawable::Extensions::glBindBuffer(GLenum target, GLuint buffer) const 
    12891289{ 
    1290     if (_glBindBuffer) _glBindBuffer(target, buffer);  
     1290    if (_glBindBuffer) _glBindBuffer(target, buffer); 
    12911291    else OSG_WARN<<"Error: glBindBuffer not supported by OpenGL driver"<<std::endl; 
    12921292} 
     
    12941294void Drawable::Extensions::glBufferData(GLenum target, GLsizeiptrARB size, const GLvoid *data, GLenum usage) const 
    12951295{ 
    1296     if (_glBufferData) _glBufferData(target, size, data, usage);  
     1296    if (_glBufferData) _glBufferData(target, size, data, usage); 
    12971297    else OSG_WARN<<"Error: glBufferData not supported by OpenGL driver"<<std::endl; 
    12981298} 
     
    13001300void Drawable::Extensions::glBufferSubData(GLenum target, GLintptrARB offset, GLsizeiptrARB size, const GLvoid *data) const 
    13011301{ 
    1302     if (_glBufferSubData) _glBufferSubData(target, offset, size, data);  
     1302    if (_glBufferSubData) _glBufferSubData(target, offset, size, data); 
    13031303    else OSG_WARN<<"Error: glBufferData not supported by OpenGL driver"<<std::endl; 
    13041304} 
     
    13061306void Drawable::Extensions::glDeleteBuffers(GLsizei n, const GLuint *buffers) const 
    13071307{ 
    1308     if (_glDeleteBuffers) _glDeleteBuffers(n, buffers);  
     1308    if (_glDeleteBuffers) _glDeleteBuffers(n, buffers); 
    13091309    else OSG_WARN<<"Error: glBufferData not supported by OpenGL driver"<<std::endl; 
    13101310} 
     
    13131313{ 
    13141314    if (_glIsBuffer) return _glIsBuffer(buffer); 
    1315     else  
     1315    else 
    13161316    { 
    13171317        OSG_WARN<<"Error: glIsBuffer not supported by OpenGL driver"<<std::endl; 
     
    13291329{ 
    13301330    if (_glMapBuffer) return _glMapBuffer(target,access); 
    1331     else  
     1331    else 
    13321332    { 
    13331333        OSG_WARN<<"Error: glMapBuffer not supported by OpenGL driver"<<std::endl; 
     
    13391339{ 
    13401340    if (_glUnmapBuffer) return _glUnmapBuffer(target); 
    1341     else  
     1341    else 
    13421342    { 
    13431343        OSG_WARN<<"Error: glUnmapBuffer not supported by OpenGL driver"<<std::endl; 
     
    13681368    { 
    13691369        OSG_WARN<<"Error: glGenOcclusionQueries not supported by OpenGL driver"<<std::endl; 
    1370     }     
     1370    } 
    13711371} 
    13721372 
     
    13801380    { 
    13811381        OSG_WARN<<"Error: glDeleteOcclusionQueries not supported by OpenGL driver"<<std::endl; 
    1382     }     
     1382    } 
    13831383} 
    13841384 
     
    13921392    { 
    13931393        OSG_WARN<<"Error: glIsOcclusionQuery not supported by OpenGL driver"<<std::endl; 
    1394     }     
     1394    } 
    13951395 
    13961396    return GLboolean( 0 ); 
     
    14061406    { 
    14071407        OSG_WARN<<"Error: glBeginOcclusionQuery not supported by OpenGL driver"<<std::endl; 
    1408     }     
     1408    } 
    14091409} 
    14101410 
     
    14181418    { 
    14191419        OSG_WARN<<"Error: glEndOcclusionQuery not supported by OpenGL driver"<<std::endl; 
    1420     }     
     1420    } 
    14211421} 
    14221422 
     
    14301430    { 
    14311431        OSG_WARN<<"Error: glGetOcclusionQueryiv not supported by OpenGL driver"<<std::endl; 
    1432     }     
     1432    } 
    14331433} 
    14341434 
     
    14421442    { 
    14431443        OSG_WARN<<"Error: glGetOcclusionQueryuiv not supported by OpenGL driver"<<std::endl; 
    1444     }     
     1444    } 
    14451445} 
    14461446 
     
    14951495void Drawable::Extensions::glDeleteQueries(GLsizei n, const GLuint *ids) const 
    14961496{ 
    1497     if (_gl_delete_queries_arb)  
     1497    if (_gl_delete_queries_arb) 
    14981498        _gl_delete_queries_arb(n, ids); 
    14991499    else