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/osgShadow/OccluderGeometry.cpp

    r11478 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*/ 
     
    3434    osg::Drawable(oc,copyop) 
    3535{ 
    36      
     36 
    3737} 
    3838 
     
    5454    { 
    5555        if (node.getStateSet()) pushState(node.getStateSet()); 
    56          
     56 
    5757        traverse(node); 
    5858 
    5959        if (node.getStateSet()) popState(); 
    6060    } 
    61      
     61 
    6262    void apply(osg::Transform& transform) 
    6363    { 
    6464        if (transform.getStateSet()) pushState(transform.getStateSet()); 
    65          
     65 
    6666        osg::Matrix matrix; 
    6767        if (!_matrixStack.empty()) matrix = _matrixStack.back(); 
    68          
     68 
    6969        transform.computeLocalToWorldMatrix(matrix,this); 
    70          
     70 
    7171        pushMatrix(matrix); 
    72          
     72 
    7373        traverse(transform); 
    74          
     74 
    7575        popMatrix(); 
    7676 
    7777        if (transform.getStateSet()) popState(); 
    7878    } 
    79      
     79 
    8080    void apply(osg::Geode& geode) 
    8181    { 
     
    8787 
    8888            if (drawable->getStateSet()) pushState(drawable->getStateSet()); 
    89              
     89 
    9090            apply(geode.getDrawable(i)); 
    9191 
    9292            if (drawable->getStateSet()) popState(); 
    9393        } 
    94          
     94 
    9595        if (geode.getStateSet()) popState(); 
    9696    } 
    97      
     97 
    9898    void pushState(osg::StateSet* stateset) 
    9999    { 
    100100        osg::StateAttribute::GLModeValue prevBlendModeValue = _blendModeStack.empty() ? osg::StateAttribute::GLModeValue(osg::StateAttribute::INHERIT) : _blendModeStack.back(); 
    101101        osg::StateAttribute::GLModeValue newBlendModeValue = stateset->getMode(GL_BLEND); 
    102          
    103         if (!(newBlendModeValue & osg::StateAttribute::PROTECTED) &&  
     102 
     103        if (!(newBlendModeValue & osg::StateAttribute::PROTECTED) && 
    104104             (prevBlendModeValue & osg::StateAttribute::OVERRIDE) ) 
    105105        { 
    106106            newBlendModeValue = prevBlendModeValue; 
    107107        } 
    108          
     108 
    109109        _blendModeStack.push_back(newBlendModeValue); 
    110110    } 
    111      
     111 
    112112    void popState() 
    113113    { 
    114114        _blendModeStack.pop_back(); 
    115115    } 
    116      
     116 
    117117    void pushMatrix(osg::Matrix& matrix) 
    118118    { 
    119119        _matrixStack.push_back(matrix); 
    120120    } 
    121      
     121 
    122122    void popMatrix() 
    123123    { 
     
    133133            return; 
    134134        } 
    135          
     135 
    136136        _oc->processGeometry(drawable, (_matrixStack.empty() ? 0 : &_matrixStack.back()), _ratio); 
    137          
    138     } 
    139      
     137 
     138    } 
     139 
    140140protected: 
    141      
     141 
    142142    OccluderGeometry* _oc; 
    143      
     143 
    144144    typedef std::vector<osg::Matrix> MatrixStack; 
    145145    typedef std::vector<osg::StateAttribute::GLModeValue> ModeStack; 
    146      
     146 
    147147    float           _ratio; 
    148148    MatrixStack     _matrixStack; 
    149149    ModeStack       _blendModeStack; 
    150      
     150 
    151151}; 
    152152 
     
    156156 
    157157    osg::Timer_t startTick = osg::Timer::instance()->tick(); 
    158      
     158 
    159159    CollectOccludersVisitor cov(this, matrix, sampleRatio); 
    160160    subgraph->accept(cov); 
    161      
     161 
    162162    setUpInternalStructures(); 
    163163 
     
    182182    typedef std::vector<const osg::Vec3*> VertexPointers; 
    183183    VertexPointers _vertexPointers; 
    184      
     184 
    185185    OccluderGeometry::Vec3List _tempoaryTriangleVertices; 
    186186 
     
    204204            _tempoaryTriangleVertices.push_back(v2); 
    205205            _tempoaryTriangleVertices.push_back(v3); 
    206              
     206 
    207207        } 
    208208        else 
     
    215215 
    216216    } 
    217      
     217 
    218218    void copyToLocalData() 
    219219    { 
    220220        if ((_vertexPointers.size()+_tempoaryTriangleVertices.size())<3) return; 
    221      
    222      
     221 
     222 
    223223        const osg::Vec3* minVertex = _vertexPointers.empty() ? 0 : _vertexPointers.front(); 
    224224        const osg::Vec3* maxVertex = _vertexPointers.empty() ? 0 : _vertexPointers.front(); 
    225      
     225 
    226226        VertexPointers::iterator itr; 
    227227        for(itr = _vertexPointers.begin(); 
     
    235235        unsigned int base = _vertices->size(); 
    236236        unsigned int numberNewVertices = _vertexPointers.empty() ? 0 : (maxVertex - minVertex) + 1; 
    237          
     237 
    238238        // OSG_NOTICE<<"base = "<<base<<" numberNewVertices="<<numberNewVertices<<std::endl; 
    239239 
    240240        _vertices->resize(base + numberNewVertices + _tempoaryTriangleVertices.size()); 
    241          
     241 
    242242        for(itr = _vertexPointers.begin(); 
    243243            itr != _vertexPointers.end(); 
     
    267267            } 
    268268        } 
    269          
     269 
    270270    } 
    271271 
     
    282282 
    283283    drawable->accept(tc); 
    284      
     284 
    285285    tc.copyToLocalData(); 
    286      
    287 #if 0     
     286 
     287#if 0 
    288288    for(Vec3List::iterator vitr = _vertices.begin(); 
    289289        vitr != _vertices.end(); 
     
    308308 
    309309    removeDuplicateVertices(); 
    310      
     310 
    311311    osg::Timer_t t1 = osg::Timer::instance()->tick(); 
    312312 
     
    320320 
    321321    buildEdgeMaps(); 
    322      
     322 
    323323    osg::Timer_t t4 = osg::Timer::instance()->tick(); 
    324324 
     
    332332 
    333333    dirtyBound(); 
    334      
     334 
    335335    dirtyDisplayList(); 
    336336} 
     
    367367{ 
    368368    if (_vertices.empty()) return; 
    369      
     369 
    370370    OSG_NOTICE<<"OccluderGeometry::removeDuplicates() before = "<<_vertices.size()<<std::endl; 
    371371 
     
    400400        else 
    401401        { 
    402             prev = curr;  
     402            prev = curr; 
    403403            ++numUnique; 
    404404        } 
    405405    } 
    406      
     406 
    407407    OSG_NOTICE<<"Num diplicates = "<<numDuplicates<<std::endl; 
    408408    OSG_NOTICE<<"Num unique = "<<numUnique<<std::endl; 
     
    410410    if (numDuplicates==0) return; 
    411411 
    412     // now assign the unique Vec3 to the newVertices arrays     
     412    // now assign the unique Vec3 to the newVertices arrays 
    413413    typedef std::vector<unsigned int> IndexMap; 
    414414    IndexMap indexMap(indexVec3PtrPairs.size()); 
     
    429429    for(; curr != indexVec3PtrPairs.end(); ++curr) 
    430430    { 
    431         if (*prev==*curr)  
     431        if (*prev==*curr) 
    432432        { 
    433433            indexMap[curr->index] = index; 
     
    435435        else 
    436436        { 
    437             ++index;             
    438              
     437            ++index; 
     438 
    439439            // add new unique vertex 
    440440            indexMap[curr->index] = index; 
    441441            newVertices.push_back(*(curr->vec)); 
    442442 
    443             prev = curr;  
     443            prev = curr; 
    444444        } 
    445445    } 
     
    462462    // OSG_NOTICE<<"OccluderGeometry::removeNullTriangles()"<<std::endl; 
    463463 
    464      
     464 
    465465    UIntList::iterator lastValidItr = _triangleIndices.begin(); 
    466466    for(UIntList::iterator titr = _triangleIndices.begin(); 
     
    501501{ 
    502502    // OSG_NOTICE<<"OccluderGeometry::computeNormals()"<<std::endl; 
    503      
     503 
    504504    unsigned int numTriangles = _triangleIndices.size() / 3; 
    505505    unsigned int redundentIndices = _triangleIndices.size() - numTriangles * 3; 
     
    509509        _triangleIndices.erase(_triangleIndices.begin() + numTriangles * 3, _triangleIndices.end()); 
    510510    } 
    511      
     511 
    512512    _triangleNormals.clear(); 
    513513    _triangleNormals.reserve(numTriangles); 
    514      
     514 
    515515    _normals.resize(_vertices.size()); 
    516516 
     
    529529 
    530530        if (!_normals.empty()) 
    531         {         
     531        { 
    532532            _normals[p1] += normal; 
    533533            _normals[p2] += normal; 
     
    535535        } 
    536536    } 
    537      
     537 
    538538    for(Vec3List::iterator nitr = _normals.begin(); 
    539539        nitr != _normals.end(); 
     
    543543    } 
    544544 
    545      
     545 
    546546} 
    547547 
     
    549549{ 
    550550    // OSG_NOTICE<<"OccluderGeometry::buildEdgeMaps()"<<std::endl; 
    551      
     551 
    552552    typedef std::set<Edge> EdgeSet; 
    553553    EdgeSet edgeSet; 
    554      
     554 
    555555    unsigned int numTriangleErrors = 0; 
    556556    unsigned int triNo=0; 
     
    562562        GLuint p2 = *titr++; 
    563563        GLuint p3 = *titr++; 
    564          
     564 
    565565        { 
    566566            Edge edge12(p1,p2); 
    567567            EdgeSet::iterator itr = edgeSet.find(edge12); 
    568             if (itr == edgeSet.end())  
     568            if (itr == edgeSet.end()) 
    569569            { 
    570570                if (!edge12.addTriangle(triNo)) ++numTriangleErrors; 
     
    577577        } 
    578578 
    579         {         
     579        { 
    580580            Edge edge23(p2,p3); 
    581581            EdgeSet::iterator itr = edgeSet.find(edge23); 
    582             if (itr == edgeSet.end())  
     582            if (itr == edgeSet.end()) 
    583583            { 
    584584                if (!edge23.addTriangle(triNo)) ++numTriangleErrors; 
     
    590590            } 
    591591        } 
    592          
     592 
    593593        { 
    594594            Edge edge31(p3,p1); 
    595595            EdgeSet::iterator itr = edgeSet.find(edge31); 
    596             if (itr == edgeSet.end())  
     596            if (itr == edgeSet.end()) 
    597597            { 
    598598                if (!edge31.addTriangle(triNo)) ++numTriangleErrors; 
    599                  
     599 
    600600                edgeSet.insert(edge31); 
    601601            } 
     
    609609    _edges.clear(); 
    610610    _edges.reserve(edgeSet.size()); 
    611      
     611 
    612612    unsigned int numEdgesWithNoTriangles = 0; 
    613613    unsigned int numEdgesWithOneTriangles = 0; 
    614614    unsigned int numEdgesWithTwoTriangles = 0; 
    615      
     615 
    616616    for(EdgeSet::iterator eitr = edgeSet.begin(); 
    617617        eitr != edgeSet.end(); 
     
    635635            pos = _vertices[opposite]; 
    636636        } 
    637          
     637 
    638638        if (edge._t2>=0) 
    639639        { 
     
    656656                edge._normal.set(0.0,0.0,0.0); 
    657657                OSG_NOTICE<<"Warning no triangles on edge."<<std::endl; 
    658                 break;  
     658                break; 
    659659            case(1): 
    660660                ++numEdgesWithOneTriangles; 
    661661                edge._normal = pos - mid; 
    662662                edge._normal.normalize(); 
    663                 break;  
     663                break; 
    664664            default: 
    665                 ++numEdgesWithTwoTriangles;  
     665                ++numEdgesWithTwoTriangles; 
    666666                edge._normal = (pos*0.5f) - mid; 
    667667                edge._normal.normalize(); 
    668                 break;  
     668                break; 
    669669        } 
    670670 
     
    687687{ 
    688688    silhouetteIndices.clear(); 
    689      
     689 
    690690    for(EdgeList::const_iterator eitr = _edges.begin(); 
    691691        eitr != _edges.end(); 
     
    699699            osg::Vec3 normal = (v2-v1) ^ lightdirection; 
    700700            if (normal * edge._normal > 0.0) 
    701             {         
     701            { 
    702702                silhouetteIndices.push_back(edge._p1); 
    703703                silhouetteIndices.push_back(edge._p2); 
     
    715715{ 
    716716    silhouetteIndices.clear(); 
    717      
     717 
    718718    for(EdgeList::const_iterator eitr = _edges.begin(); 
    719719        eitr != _edges.end(); 
     
    727727            osg::Vec3 normal = (v2-v1) ^ (v1-lightpos); 
    728728            if (normal * edge._normal > 0.0) 
    729             {         
     729            { 
    730730                silhouetteIndices.push_back(edge._p1); 
    731731                silhouetteIndices.push_back(edge._p2); 
     
    765765        // directional light. 
    766766        osg::Vec3 lightdirection( -lightpos.x(), -lightpos.y(), -lightpos.z()); 
    767          
     767 
    768768        // OSG_NOTICE<<"Directional light"<<std::endl; 
    769          
     769 
    770770        // choose the base plane 
    771771        const osg::Polytope::PlaneList& planes = _boundingPolytope.getPlaneList(); 
     
    787787        UIntList silhouetteIndices; 
    788788        computeLightDirectionSilhouetteEdges(lightdirection, silhouetteIndices); 
    789          
     789 
    790790        osg::Vec3 offset( lightdirection*5.0f ); 
    791          
     791 
    792792        float directionScale = 1.0f / basePlane.dotProductNormal(lightdirection); 
    793          
     793 
    794794        for(UIntList::iterator itr = silhouetteIndices.begin(); 
    795795            itr != silhouetteIndices.end(); 
     
    829829        UIntList silhouetteIndices; 
    830830        computeLightPositionSilhouetteEdges(lightposition, silhouetteIndices); 
    831          
     831 
    832832        // OSG_NOTICE<<"basePlane "<<basePlane[0]<<" "<<basePlane[1]<<" "<<basePlane[2]<<" "<<basePlane[3]<<std::endl; 
    833833        // OSG_NOTICE<<"lightpos  = "<<std::endl; 
     
    840840            const osg::Vec3& v1 = _vertices[*itr++]; 
    841841            const osg::Vec3& v2 = _vertices[*itr++]; 
    842              
     842 
    843843            osg::Vec3 d1 = v1 - lightposition; 
    844844            osg::Vec3 d2 = v2 - lightposition; 
     
    893893 
    894894    renderInfo.getState()->setVertexPointer( 3, GL_FLOAT, 0, &(_vertices.front()) ); 
    895      
     895 
    896896    if (!_normals.empty()) 
    897897    { 
     
    937937    { 
    938938        osg::State* state = renderInfo.getState(); 
    939          
     939 
    940940        state->disableAllVertexArrays(); 
    941941 
     
    959959    { 
    960960        osg::State* state = renderInfo.getState(); 
    961          
     961 
    962962        state->disableAllVertexArrays(); 
    963963        state->setVertexPointer( 3, GL_FLOAT, 0, &(_vertices.front()) ); 
     
    968968 
    969969        glDrawArrays( GL_QUADS, 0, _vertices.size() ); 
    970          
     970 
    971971        // draw back faces of shadow volume 
    972972        glCullFace(GL_FRONT); 
     
    974974 
    975975        glDrawArrays( GL_QUADS, 0, _vertices.size() ); 
    976          
     976 
    977977        state->haveAppliedAttribute(osg::StateAttribute::CULLFACE); 
    978978        state->haveAppliedAttribute(osg::StateAttribute::STENCIL); 
     
    982982    { 
    983983        osg::State* state = renderInfo.getState(); 
    984          
     984 
    985985        state->disableAllVertexArrays(); 
    986986        state->setVertexPointer( 3, GL_FLOAT, 0, &(_vertices.front()) );