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/ShapeDrawable.cpp

    r12597 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*/ 
     
    3030{ 
    3131    public: 
    32      
     32 
    3333        DrawShapeVisitor(State& state,const TessellationHints* hints): 
    3434            _state(state), 
     
    4040                OSG_NOTICE<<"Warning: TessellationHints ignored in present osg::ShapeDrawable implementation."<<std::endl; 
    4141            } 
    42 #endif    
     42#endif 
    4343        } 
    44      
     44 
    4545        virtual void apply(const Sphere&); 
    4646        virtual void apply(const Box&); 
     
    5858        State&                      _state; 
    5959        const TessellationHints*    _hints; 
    60          
     60 
    6161    protected: 
    6262 
     
    6464 
    6565        enum SphereHalf { SphereTopHalf, SphereBottomHalf }; 
    66      
     66 
    6767        // helpers for apply( Cylinder | Sphere | Capsule ) 
    6868        void drawCylinderBody(unsigned int numSegments, float radius, float height); 
     
    7575    const float angleDelta = 2.0f*osg::PI/(float)numSegments; 
    7676    const float texCoordDelta = 1.0f/(float)numSegments; 
    77      
     77 
    7878    const float r = radius; 
    7979    const float h = height; 
    80      
     80 
    8181    float basez = -h*0.5f; 
    8282    float topz = h*0.5f; 
    83      
     83 
    8484    float angle = 0.0f; 
    8585    float texCoord = 0.0f; 
    86      
     86 
    8787    bool drawFrontFace = _hints ? _hints->getCreateFrontFace() : true; 
    8888    bool drawBackFace = _hints ? _hints->getCreateBackFace() : false; 
    89      
     89 
    9090    // The only difference between the font & back face loops is that the 
    9191    //  normals are inverted and the order of the vertex pairs is reversed. 
    92     //  The code is mostly duplicated in order to hoist the back/front face  
     92    //  The code is mostly duplicated in order to hoist the back/front face 
    9393    //  test out of the loop for efficiency 
    9494 
     
    105105          float c = cosf(angle); 
    106106          float s = sinf(angle); 
    107    
     107 
    108108          gl.Normal3f(c,s,0.0f); 
    109    
     109 
    110110          gl.TexCoord2f(texCoord,1.0f); 
    111111          gl.Vertex3f(c*r,s*r,topz); 
    112    
     112 
    113113          gl.TexCoord2f(texCoord,0.0f); 
    114114          gl.Vertex3f(c*r,s*r,basez); 
    115115      } 
    116    
     116 
    117117      // do last point by hand to ensure no round off errors. 
    118118      gl.Normal3f(1.0f,0.0f,0.0f); 
    119    
     119 
    120120      gl.TexCoord2f(1.0f,1.0f); 
    121121      gl.Vertex3f(r,0.0f,topz); 
    122    
     122 
    123123      gl.TexCoord2f(1.0f,0.0f); 
    124124      gl.Vertex3f(r,0.0f,basez); 
    125125    } 
    126      
     126 
    127127    if (drawBackFace) { 
    128128      for(unsigned int bodyi=0; 
     
    132132          float c = cosf(angle); 
    133133          float s = sinf(angle); 
    134    
     134 
    135135          gl.Normal3f(-c,-s,0.0f); 
    136    
     136 
    137137          gl.TexCoord2f(texCoord,0.0f); 
    138138          gl.Vertex3f(c*r,s*r,basez); 
     
    141141          gl.Vertex3f(c*r,s*r,topz); 
    142142      } 
    143    
     143 
    144144      // do last point by hand to ensure no round off errors. 
    145145      gl.Normal3f(-1.0f,0.0f,0.0f); 
    146    
     146 
    147147      gl.TexCoord2f(1.0f,0.0f); 
    148148      gl.Vertex3f(r,0.0f,basez); 
    149    
     149 
    150150      gl.TexCoord2f(1.0f,1.0f); 
    151151      gl.Vertex3f(r,0.0f,topz); 
     
    198198            // The only difference between the font & back face loops is that the 
    199199            //  normals are inverted and the order of the vertex pairs is reversed. 
    200             //  The code is mostly duplicated in order to hoist the back/front face  
     200            //  The code is mostly duplicated in order to hoist the back/front face 
    201201            //  test out of the loop for efficiency 
    202              
     202 
    203203            if (drawFrontFace) { 
    204204              for(unsigned int topi=0; topi<numSegments; 
    205205                  ++topi,angle+=angleDelta,texCoord+=texCoordHorzDelta) 
    206206              { 
    207    
     207 
    208208                  float c = cosf(angle); 
    209209                  float s = sinf(angle); 
    210    
     210 
    211211                  gl.Normal3f(c*nRatioTop,s*nRatioTop,nzTop); 
    212    
     212 
    213213                  gl.TexCoord2f(texCoord,vTop); 
    214214                  gl.Vertex3f(c*rTop,s*rTop,zTop+zOffset); 
    215    
     215 
    216216                  gl.Normal3f(c*nRatioBase,s*nRatioBase,nzBase); 
    217    
     217 
    218218                  gl.TexCoord2f(texCoord,vBase); 
    219219                  gl.Vertex3f(c*rBase,s*rBase,zBase+zOffset); 
    220    
     220 
    221221              } 
    222    
     222 
    223223              // do last point by hand to ensure no round off errors. 
    224224              gl.Normal3f(nRatioTop,0.0f,nzTop); 
    225    
     225 
    226226              gl.TexCoord2f(1.0f,vTop); 
    227227              gl.Vertex3f(rTop,0.0f,zTop+zOffset); 
    228    
     228 
    229229              gl.Normal3f(nRatioBase,0.0f,nzBase); 
    230    
     230 
    231231              gl.TexCoord2f(1.0f,vBase); 
    232232              gl.Vertex3f(rBase,0.0f,zBase+zOffset); 
    233233            } 
    234              
     234 
    235235          if (drawBackFace) { 
    236236              for(unsigned int topi=0; topi<numSegments; 
    237237                  ++topi,angle+=angleDelta,texCoord+=texCoordHorzDelta) 
    238238              { 
    239    
     239 
    240240                  float c = cosf(angle); 
    241241                  float s = sinf(angle); 
    242    
     242 
    243243                  gl.Normal3f(-c*nRatioBase,-s*nRatioBase,-nzBase); 
    244    
     244 
    245245                  gl.TexCoord2f(texCoord,vBase); 
    246246                  gl.Vertex3f(c*rBase,s*rBase,zBase+zOffset); 
    247    
     247 
    248248                  gl.Normal3f(-c*nRatioTop,-s*nRatioTop,-nzTop); 
    249    
     249 
    250250                  gl.TexCoord2f(texCoord,vTop); 
    251251                  gl.Vertex3f(c*rTop,s*rTop,zTop+zOffset); 
    252252              } 
    253    
     253 
    254254              // do last point by hand to ensure no round off errors. 
    255255              gl.Normal3f(-nRatioBase,0.0f,-nzBase); 
    256    
     256 
    257257              gl.TexCoord2f(1.0f,vBase); 
    258258              gl.Vertex3f(rBase,0.0f,zBase+zOffset); 
    259259 
    260260              gl.Normal3f(-nRatioTop,0.0f,-nzTop); 
    261    
     261 
    262262              gl.TexCoord2f(1.0f,vTop); 
    263263              gl.Vertex3f(rTop,0.0f,zTop+zOffset); 
    264    
     264 
    265265          } 
    266266 
     
    725725 
    726726    // cylinder body 
    727     if (createBody)  
     727    if (createBody) 
    728728        drawCylinderBody(numSegments, cylinder.getRadius(), cylinder.getHeight()); 
    729729 
     
    831831 
    832832    // capsule cylindrical body 
    833     if (createBody)  
     833    if (createBody) 
    834834        drawCylinderBody(numSegments, capsule.getRadius(), capsule.getHeight()); 
    835835 
    836836    // capsule top cap 
    837     if (createTop)  
     837    if (createTop) 
    838838        drawHalfSphere(numSegments, numRows, capsule.getRadius(), SphereTopHalf, capsule.getHeight()/2.0f); 
    839839 
    840840    // capsule bottom cap 
    841     if (createBottom)  
     841    if (createBottom) 
    842842        drawHalfSphere(numSegments, numRows, capsule.getRadius(), SphereBottomHalf, -capsule.getHeight()/2.0f); 
    843843 
     
    856856    const Vec3Array* vertices = mesh.getVertices(); 
    857857    const IndexArray* indices = mesh.getIndices(); 
    858      
     858 
    859859     if (vertices && indices) 
    860860     { 
     
    10611061{ 
    10621062    public: 
    1063      
     1063 
    10641064        ComputeBoundShapeVisitor(BoundingBox& bb):_bb(bb) {} 
    10651065 
     
    12371237    const Vec3Array* vertices = mesh.getVertices(); 
    12381238    const IndexArray* indices = mesh.getIndices(); 
    1239      
     1239 
    12401240    if (vertices && indices) 
    12411241    { 
     
    13281328{ 
    13291329    public: 
    1330      
     1330 
    13311331        PrimitiveShapeVisitor(PrimitiveFunctor& functor,const TessellationHints* hints): 
    13321332            _functor(functor), 
     
    13631363{ 
    13641364    const float angleDelta = 2.0f*osg::PI/(float)numSegments; 
    1365      
     1365 
    13661366    const float r = radius; 
    13671367    const float h = height; 
    1368      
     1368 
    13691369    float basez = -h*0.5f; 
    13701370    float topz = h*0.5f; 
    1371      
     1371 
    13721372    float angle = 0.0f; 
    1373      
     1373 
    13741374    _functor.begin(GL_QUAD_STRIP); 
    13751375 
     
    13881388        _functor.vertex(osg::Vec3(r,0.0f,topz) * matrix); 
    13891389        _functor.vertex(osg::Vec3(r,0.0f,basez) * matrix); 
    1390      
     1390 
    13911391    _functor.end(); 
    13921392} 
     
    14341434 
    14351435            } 
    1436    
     1436 
    14371437            // do last point by hand to ensure no round off errors. 
    14381438            _functor.vertex(osg::Vec3(rTop,0.0f,zTop+zOffset) * matrix); 
    1439             _functor.vertex(osg::Vec3(rBase,0.0f,zBase+zOffset) * matrix);             
     1439            _functor.vertex(osg::Vec3(rBase,0.0f,zBase+zOffset) * matrix); 
    14401440 
    14411441        _functor.end(); 
    1442          
    1443          
     1442 
     1443 
    14441444        lBase=lTop; 
    14451445        rBase=rTop; 
     
    14471447        vBase=vTop; 
    14481448    } 
    1449          
     1449 
    14501450} 
    14511451 
     
    15591559        Matrix matrix = box.computeRotationMatrix(); 
    15601560        matrix.setTrans(box.getCenter()); 
    1561          
     1561 
    15621562        base_1 = base_1*matrix; 
    15631563        base_2 = base_2*matrix; 
     
    18441844    const Vec3Array* vertices = mesh.getVertices(); 
    18451845    const IndexArray* indices = mesh.getIndices(); 
    1846      
     1846 
    18471847     if (vertices && indices) 
    18481848     { 
     
    18701870{ 
    18711871    if (field.getNumColumns()==0 || field.getNumRows()==0) return; 
    1872      
     1872 
    18731873    Matrix matrix = field.computeRotationMatrix(); 
    18741874    matrix.setTrans(field.getOrigin()); 
     
    19481948void ShapeDrawable::setTessellationHints(TessellationHints* hints) 
    19491949{ 
    1950     if (_tessellationHints!=hints)  
    1951     { 
    1952         _tessellationHints = hints;  
     1950    if (_tessellationHints!=hints) 
     1951    { 
     1952        _tessellationHints = hints; 
    19531953        dirtyDisplayList(); 
    19541954    } 
     
    19631963    { 
    19641964        gl.Color4fv(_color.ptr()); 
    1965      
     1965 
    19661966        DrawShapeVisitor dsv(state,_tessellationHints.get()); 
    1967          
     1967 
    19681968        _shape->accept(dsv); 
    19691969    }