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/osgSim/OverlayNode.cpp

    r12389 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*/ 
     
    6060        const osg::Vec3d v101(1.0,-1.0,1.0); 
    6161        const osg::Vec3d v111(1.0,1.0,1.0); 
    62          
     62 
    6363        _faces.clear(); 
    6464 
     
    6767            face.name = "left"; 
    6868            face.plane.set(1.0,0.0,0.0,1.0); 
    69             face.vertices.reserve(4);                                                                                       
     69            face.vertices.reserve(4); 
    7070            face.vertices.push_back(v000); 
    7171            face.vertices.push_back(v001); 
     
    106106            face.vertices.push_back(v110); 
    107107        } 
    108          
     108 
    109109        if (withNear) 
    110110        {   // near plane 
     
    117117            face.vertices.push_back(v110); 
    118118            face.vertices.push_back(v100); 
    119         }         
    120          
     119        } 
     120 
    121121        if (withFar) 
    122122        {   // far plane 
     
    129129            face.vertices.push_back(v111); 
    130130            face.vertices.push_back(v011); 
    131         }         
     131        } 
    132132 
    133133    } 
     
    135135    void setToBoundingBox(const osg::BoundingBox& bb) 
    136136    { 
    137 #if 0     
     137#if 0 
    138138        OSG_NOTICE<<"setToBoundingBox xrange "<<bb.xMin()<<" "<<bb.xMax()<<std::endl; 
    139139        OSG_NOTICE<<"                        "<<bb.yMin()<<" "<<bb.yMax()<<std::endl; 
    140140        OSG_NOTICE<<"                        "<<bb.zMin()<<" "<<bb.zMax()<<std::endl; 
    141 #endif     
     141#endif 
    142142        const osg::Vec3d v000(bb.xMin(),bb.yMin(), bb.zMin()); 
    143143        const osg::Vec3d v010(bb.xMin(),bb.yMax(), bb.zMin()); 
     
    148148        const osg::Vec3d v101(bb.xMax(),bb.yMin(), bb.zMax()); 
    149149        const osg::Vec3d v111(bb.xMax(),bb.yMax(), bb.zMax()); 
    150          
     150 
    151151        _faces.clear(); 
    152152 
     
    203203            face.vertices.push_back(v110); 
    204204            face.vertices.push_back(v100); 
    205         }         
    206          
     205        } 
     206 
    207207        {   // z max plane 
    208208            Face& face = createFace(); 
     
    214214            face.vertices.push_back(v111); 
    215215            face.vertices.push_back(v011); 
    216         }         
    217          
     216        } 
     217 
    218218    } 
    219219 
     
    232232                *vitr = *vitr * matrix; 
    233233            } 
    234         }         
     234        } 
    235235    } 
    236236 
     
    239239    { 
    240240        // OSG_NOTICE<<"Inserting vertex "<<vertex<<std::endl; 
    241      
     241 
    242242        Faces removedFaces; 
    243      
     243 
    244244        Faces::iterator itr; 
    245245        for(itr = _faces.begin(); 
     
    258258            } 
    259259        } 
    260          
    261         if (removedFaces.empty()) return;         
     260 
     261        if (removedFaces.empty()) return; 
    262262 
    263263        typedef std::pair<osg::Vec3d, osg::Vec3d> Edge; 
     
    265265        Edges edges; 
    266266 
    267         double numVerticesAdded=0.0;         
     267        double numVerticesAdded=0.0; 
    268268        osg::Vec3d center; 
    269269        for(itr = removedFaces.begin(); 
     
    279279                if (a<b) ++edges[Edge(a,b)]; 
    280280                else ++edges[Edge(b,a)]; 
    281                  
     281 
    282282                center += a; 
    283283                numVerticesAdded += 1.0; 
    284284            } 
    285285        } 
    286          
     286 
    287287        if (numVerticesAdded==0.0) return; 
    288288        center /= numVerticesAdded; 
    289          
     289 
    290290        typedef std::set<osg::Vec3> VertexSet; 
    291291        VertexSet uniqueVertices; 
    292          
     292 
    293293        for(Edges::iterator eitr = edges.begin(); 
    294294            eitr != edges.end(); 
    295295            ++eitr) 
    296296        { 
    297             if (eitr->second==1)  
     297            if (eitr->second==1) 
    298298            { 
    299299                // OSG_NOTICE<<"     edge Ok"<<std::endl; 
     
    307307                if (face.plane.distance(center)<0.0) face.plane.flip(); 
    308308                _faces.push_back(face); 
    309                  
     309 
    310310                uniqueVertices.insert(edge.first); 
    311311                uniqueVertices.insert(edge.second); 
     
    329329                baseVertices.push_back(point - normal * (height - minHeight)); 
    330330            } 
    331              
     331 
    332332            //compute centroid of the base vertices 
    333333            osg::Vec3d center; 
     
    346346            osg::Vec3d normal(center); 
    347347            normal.normalize(); 
    348              
     348 
    349349            osg::Plane basePlane(normal, center); 
    350350 
    351351            cut(basePlane,"basePlane"); 
    352352        } 
    353      
     353 
    354354 
    355355        // OSG_NOTICE<<"  Removed faces "<<removedFaces.size()<<std::endl; 
     
    362362 
    363363        Faces removedFaces; 
    364      
     364 
    365365        Faces::iterator itr; 
    366366        for(itr = _faces.begin(); 
     
    379379            } 
    380380        } 
    381          
    382         if (removedFaces.empty()) return;         
     381 
     382        if (removedFaces.empty()) return; 
    383383 
    384384        typedef std::pair<osg::Vec3d, osg::Vec3d> Edge; 
     
    386386        Edges edges; 
    387387 
    388         double numVerticesAdded=0.0;         
     388        double numVerticesAdded=0.0; 
    389389        osg::Vec3d center; 
    390390        for(itr = removedFaces.begin(); 
     
    400400                if (a<b) ++edges[Edge(a,b)]; 
    401401                else ++edges[Edge(b,a)]; 
    402                  
     402 
    403403                center += a; 
    404404                numVerticesAdded += 1.0; 
    405405            } 
    406406        } 
    407          
     407 
    408408        if (numVerticesAdded==0.0) return; 
    409409        center /= numVerticesAdded; 
    410          
     410 
    411411        typedef std::set<osg::Vec3> VertexSet; 
    412412        VertexSet uniqueVertices; 
    413          
     413 
    414414        for(Edges::iterator eitr = edges.begin(); 
    415415            eitr != edges.end(); 
    416416            ++eitr) 
    417417        { 
    418             if (eitr->second==1)  
     418            if (eitr->second==1) 
    419419            { 
    420420                // OSG_NOTICE<<"     edge Ok"<<std::endl; 
    421421                const Edge& edge = eitr->first; 
    422                  
     422 
    423423                double h_first = (edge.first-control) * normal; 
    424424                osg::Vec3d projected_first = edge.first - normal * h_first; 
    425                  
     425 
    426426                double h_second = (edge.second-control) * normal; 
    427427                osg::Vec3d projected_second = edge.second - normal * h_second; 
    428                  
     428 
    429429                Face face; 
    430430                face.name = "baseSide"; 
     
    437437                if (face.plane.distance(center)<0.0) face.plane.flip(); 
    438438                _faces.push_back(face); 
    439                  
     439 
    440440                uniqueVertices.insert(projected_first); 
    441441                uniqueVertices.insert(projected_second); 
    442442            } 
    443443        } 
    444          
     444 
    445445        Face newFace; 
    446446        newFace.name = "basePlane"; 
    447447        newFace.plane.set(normal,control); 
    448          
    449         osg::Vec3d side = ( fabs(normal.x()) < fabs(normal.y()) ) ?  
     448 
     449        osg::Vec3d side = ( fabs(normal.x()) < fabs(normal.y()) ) ? 
    450450                          osg::Vec3(1.0, 0.0, 0.0) : 
    451451                          osg::Vec3(0.0, 1.0, 0.0); 
     
    475475            newFace.vertices.push_back(aitr->second); 
    476476        } 
    477          
     477 
    478478        _faces.push_back(newFace); 
    479479 
    480          
     480 
    481481    } 
    482482 
     
    490490        EdgeMap edgeMap; 
    491491 
    492          
     492 
    493493        for(Faces::iterator itr = _faces.begin(); 
    494494            itr != _faces.end(); 
     
    504504            } 
    505505        } 
    506          
     506 
    507507        typedef std::set<osg::Vec3> VertexSet; 
    508508        VertexSet uniqueVertices; 
    509          
     509 
    510510        for(EdgeMap::iterator eitr = edgeMap.begin(); 
    511511            eitr != edgeMap.end(); 
     
    520520            else if (edgeFaces.size()==2) 
    521521            { 
    522                  
     522 
    523523                double dotProduct0 = edgeFaces[0]->plane.getNormal() * normal; 
    524524                double dotProduct1 = edgeFaces[1]->plane.getNormal() * normal; 
     
    533533                    // OSG_NOTICE<<"  Non silhoette edge found "<<edgeFaces[0]->name<<" "<<edgeFaces[1]->name<<std::endl; 
    534534                } 
    535                  
     535 
    536536            } 
    537537            else 
     
    553553        } 
    554554        center /= (double)(uniqueVertices.size()); 
    555          
    556          
     555 
     556 
    557557        // compute the ordered points around silhoette 
    558         osg::Vec3d side = ( fabs(normal.x()) < fabs(normal.y()) ) ?  
     558        osg::Vec3d side = ( fabs(normal.x()) < fabs(normal.y()) ) ? 
    559559                          osg::Vec3(1.0, 0.0, 0.0) : 
    560560                          osg::Vec3(0.0, 1.0, 0.0); 
     
    584584            vertices.push_back(aitr->second); 
    585585        } 
    586          
    587          
     586 
     587 
    588588    } 
    589589 
     
    618618        Distances distances; 
    619619        Vertices newVertices; 
    620          
     620 
    621621        for(Faces::iterator itr = _faces.begin(); 
    622622            itr != _faces.end(); 
     
    627627            if (intersect==1) 
    628628            { 
    629                 // OSG_NOTICE<<"    Face inside"<<std::endl;  
     629                // OSG_NOTICE<<"    Face inside"<<std::endl; 
    630630                ++itr; 
    631631            } 
     
    633633            { 
    634634                // OSG_NOTICE<<"    Face intersecting - before "<<face.vertices.size()<<std::endl; 
    635                  
     635 
    636636                Vertices& vertices = face.vertices; 
    637637                newVertices.clear(); 
     
    645645                    distances.push_back(plane.distance(*vitr)); 
    646646                } 
    647                  
     647 
    648648                for(unsigned int i=0; i<vertices.size(); ++i) 
    649649                { 
     
    657657 
    658658                    // add point to new face if point exactly on a plane 
    659                     if (distance_a==0.0) newFace.vertices.push_back(vertices[i]);  
     659                    if (distance_a==0.0) newFace.vertices.push_back(vertices[i]); 
    660660 
    661661                    // does edge intersect plane 
     
    666666                        newVertices.push_back(intersection); 
    667667                        newFace.vertices.push_back(intersection); 
    668                          
    669                         // OSG_NOTICE<<"  intersection distance "<<plane.distance(intersection)<<std::endl;                         
     668 
     669                        // OSG_NOTICE<<"  intersection distance "<<plane.distance(intersection)<<std::endl; 
    670670                    } 
    671671                } 
    672                  
     672 
    673673                vertices.swap(newVertices); 
    674                  
     674 
    675675                // OSG_NOTICE<<"        intersecting - after "<<face.vertices.size()<<std::endl; 
    676676 
     
    679679            else if (intersect==-1) 
    680680            { 
    681                 // OSG_NOTICE<<"    Face outside"<<_faces.size()<<std::endl;  
     681                // OSG_NOTICE<<"    Face outside"<<_faces.size()<<std::endl; 
    682682                itr = _faces.erase(itr); 
    683683            } 
    684684        } 
    685          
     685 
    686686        if (!newFace.vertices.empty()) 
    687687        { 
     
    692692            Vertices& vertices = newFace.vertices; 
    693693 
    694             osg::Vec3d side = ( fabs(plane.getNormal().x()) < fabs(plane.getNormal().y()) ) ?  
     694            osg::Vec3d side = ( fabs(plane.getNormal().x()) < fabs(plane.getNormal().y()) ) ? 
    695695                              osg::Vec3(1.0, 0.0, 0.0) : 
    696696                              osg::Vec3(0.0, 1.0, 0.0); 
    697                                
     697 
    698698            osg::Vec3 v = plane.getNormal() ^ side; 
    699699            v.normalize(); 
    700              
     700 
    701701            osg::Vec3 u = v ^ plane.getNormal(); 
    702702            u.normalize(); 
     
    724724            } 
    725725 
    726              
     726 
    727727            newVertices.clear(); 
    728728            newVertices.reserve(anglePositions.size()); 
     
    733733                newVertices.push_back(aitr->second); 
    734734            } 
    735              
     735 
    736736            newVertices.swap(vertices); 
    737              
     737 
    738738            // OSG_NOTICE<<"     after angle sort  "<<newFace.vertices.size()<<std::endl; 
    739739 
     
    768768            } 
    769769        } 
    770          
     770 
    771771        for(VerticesSet::iterator sitr = verticesSet.begin(); 
    772772            sitr != verticesSet.end(); 
     
    797797            } 
    798798        } 
    799          
     799 
    800800        osg::Vec4Array* colours = new osg::Vec4Array; 
    801801        colours->push_back(colour); 
    802802        geometry->setColorArray(colours); 
    803803        geometry->setColorBinding(osg::Geometry::BIND_OVERALL); 
    804          
     804 
    805805        osg::StateSet* stateset = geometry->getOrCreateStateSet(); 
    806806        stateset->setMode(GL_LIGHTING, osg::StateAttribute::OFF); 
    807807        stateset->setTextureMode(0, GL_TEXTURE_2D, osg::StateAttribute::OFF); 
    808808        stateset->setTextureMode(1, GL_TEXTURE_2D, osg::StateAttribute::OFF); 
    809          
     809 
    810810        return geometry; 
    811811    } 
     
    816816    Faces _faces; 
    817817 
    818      
     818 
    819819}; 
    820820 
     
    850850    _renderTargetImpl(copy._renderTargetImpl) 
    851851{ 
    852     setNumChildrenRequiringUpdateTraversal(getNumChildrenRequiringUpdateTraversal()+1);             
     852    setNumChildrenRequiringUpdateTraversal(getNumChildrenRequiringUpdateTraversal()+1); 
    853853    init(); 
    854854} 
     
    884884{ 
    885885    osg::Group::setThreadSafeRefUnref(threadSafe); 
    886      
     886 
    887887    if (_overlaySubgraph.valid()) _overlaySubgraph->setThreadSafeRefUnref(threadSafe); 
    888888 
     
    912912{ 
    913913    osg::Group::releaseGLObjects(state); 
    914      
     914 
    915915    if (_overlaySubgraph.valid()) _overlaySubgraph->releaseGLObjects(state); 
    916916 
     
    926926{ 
    927927    if (_overlayTechnique==technique) return; 
    928      
     928 
    929929    _overlayTechnique = technique; 
    930      
     930 
    931931    init(); 
    932932} 
     
    952952    OverlayDataMap::iterator itr = _overlayDataMap.find(cv); 
    953953    if (itr != _overlayDataMap.end()) return itr->second.get(); 
    954      
     954 
    955955    _overlayDataMap[cv] = new OverlayData; 
    956      
     956 
    957957    OverlayData* overlayData = _overlayDataMap[cv].get(); 
    958      
    959      
     958 
     959 
    960960    unsigned int tex_width = _textureSizeHint; 
    961961    unsigned int tex_height = _textureSizeHint; 
    962      
    963     if (!overlayData->_texture)  
    964     {  
     962 
     963    if (!overlayData->_texture) 
     964    { 
    965965        // OSG_NOTICE<<"   setting up texture"<<std::endl; 
    966966 
     
    978978#endif 
    979979        overlayData->_texture = texture; 
    980     }    
     980    } 
    981981 
    982982    // set up the render to texture camera. 
     
    987987        // create the camera 
    988988        overlayData->_camera = new osg::Camera; 
    989           
     989 
    990990        overlayData->_camera->setClearColor(_overlayClearColor); 
    991991 
     
    994994        // set viewport 
    995995        overlayData->_camera->setViewport(0,0,tex_width,tex_height); 
    996          
     996 
    997997        overlayData->_camera->setComputeNearFarMode(osg::CullSettings::DO_NOT_COMPUTE_NEAR_FAR); 
    998998 
     
    10051005        // attach the texture and use it as the color buffer. 
    10061006        overlayData->_camera->attach(osg::Camera::COLOR_BUFFER, overlayData->_texture.get()); 
    1007          
     1007 
    10081008        if (_overlaySubgraph.valid()) overlayData->_camera->addChild(_overlaySubgraph.get()); 
    10091009    } 
     
    10181018    if (!overlayData->_lightingEnabled) overlayData->_lightingEnabled = new osg::Uniform("lightingEnabled",true); 
    10191019 
    1020     if (!overlayData->_overlayStateSet)  
     1020    if (!overlayData->_overlayStateSet) 
    10211021    { 
    10221022        overlayData->_overlayStateSet = new osg::StateSet; 
     
    10351035        else 
    10361036        { 
    1037             char vertexShaderSource[] =  
     1037            char vertexShaderSource[] = 
    10381038                "uniform float y0; \n" 
    10391039                "uniform bool lightingEnabled; \n" 
     
    11111111            program->addShader(vertex_shader); 
    11121112        } 
    1113          
     1113 
    11141114    } 
    11151115 
     
    11261126        else 
    11271127        { 
    1128             char fragmentShaderSource[] =  
     1128            char fragmentShaderSource[] = 
    11291129                "uniform sampler2D texture_0; \n" 
    11301130                "uniform sampler2D texture_1; \n" 
     
    11591159    } 
    11601160 
    1161     if (!overlayData->_mainSubgraphStateSet)  
     1161    if (!overlayData->_mainSubgraphStateSet) 
    11621162    { 
    11631163        overlayData->_mainSubgraphStateSet = new osg::StateSet; 
     
    11731173        overlayData->_mainSubgraphStateSet->setTextureMode(_textureUnit, GL_TEXTURE_GEN_Q, osg::StateAttribute::ON); 
    11741174 
    1175         if (_texEnvMode!=GL_NONE)  
     1175        if (_texEnvMode!=GL_NONE) 
    11761176        { 
    11771177            overlayData->_mainSubgraphStateSet->setTextureAttribute(_textureUnit, new osg::TexEnv((osg::TexEnv::Mode)_texEnvMode)); 
     
    12011201{ 
    12021202    OSG_INFO<<"OverlayNode::init() - OBJECT_DEPENDENT_WITH_ORTHOGRAPHIC_OVERLAY"<<std::endl; 
    1203      
     1203 
    12041204    // force initialization of _overlayDataMap for the key 0 (or NULL) 
    12051205    getOverlayData(0); 
     
    12441244        if (_continuousUpdate || _updateCamera) 
    12451245        { 
    1246          
    1247          
     1246 
     1247 
    12481248            // now compute the camera's view and projection matrix to point at the shadower (the camera's children) 
    12491249            osg::BoundingSphere bs; 
     
    12671267                osg::EllipsoidModel* em = csn ? csn->getEllipsoidModel() : 0; 
    12681268 
    1269    
     1269 
    12701270                if (em) 
    12711271                { 
     
    13071307                // compute the matrix which takes a vertex from local coords into tex coords 
    13081308                // will use this later to specify osg::TexGen.. 
    1309                 osg::Matrix MVP = camera->getViewMatrix() *  
     1309                osg::Matrix MVP = camera->getViewMatrix() * 
    13101310                                  camera->getProjectionMatrix(); 
    13111311 
     
    13381338        return; 
    13391339    } 
    1340      
    1341      
     1340 
     1341 
    13421342    unsigned int contextID = cv->getState()!=0 ? cv->getState()->getContextID() : 0; 
    13431343 
     
    13491349        _textureObjectValidList[contextID] = 1; 
    13501350    } 
    1351      
    1352      
     1351 
     1352 
    13531353    // now set up the drawing of the main scene. 
    13541354    { 
    13551355 
    13561356        overlayData._texgenNode->accept(*cv); 
    1357          
     1357 
    13581358        const osg::Matrix modelView = *(cv->getModelViewMatrix()); 
    13591359        osg::Polytope viewTextureFrustum; 
     
    13621362        cv->getProjectionCullingStack().back().addStateFrustum(overlayData._mainSubgraphStateSet.get(), viewTextureFrustum); 
    13631363        cv->getCurrentCullingSet().addStateFrustum(overlayData._mainSubgraphStateSet.get(), overlayData._textureFrustum); 
    1364          
     1364 
    13651365        // push the stateset. 
    13661366        // cv->pushStateSet(_mainSubgraphStateSet.get()); 
     
    13921392        return; 
    13931393    } 
    1394      
     1394 
    13951395    OverlayData& overlayData = *getOverlayData(cv); 
    13961396    osg::Camera* camera = overlayData._camera.get(); 
    13971397 
    1398     if (_overlaySubgraph.valid())  
     1398    if (_overlaySubgraph.valid()) 
    13991399    { 
    14001400 
     
    14041404            overlayData._geode = new osg::Geode; 
    14051405        } 
    1406 #endif         
     1406#endif 
    14071407        // see if we are within a coordinate system node. 
    14081408        osg::CoordinateSystemNode* csn = 0; 
     
    14221422        cv->pushStateSet(overlayData._mainSubgraphStateSet.get()); 
    14231423 
    1424         Group::traverse(nv);     
     1424        Group::traverse(nv); 
    14251425 
    14261426        cv->popStateSet(); 
    14271427 
    14281428        osg::Matrix pm = *(cv->getProjectionMatrix()); 
    1429          
     1429 
    14301430        double znear = cv->getCalculatedNearPlane(); 
    14311431        double zfar = cv->getCalculatedFarPlane(); 
    1432          
     1432 
    14331433        // OSG_NOTICE<<" before znear ="<<znear<<"\t zfar ="<<zfar<<std::endl; 
    1434          
     1434 
    14351435        cv->computeNearPlane(); 
    1436          
     1436 
    14371437        znear = cv->getCalculatedNearPlane(); 
    14381438        zfar = cv->getCalculatedFarPlane(); 
     
    14431443 
    14441444        cv->clampProjectionMatrixImplementation(pm, znear,zfar); 
    1445          
     1445 
    14461446        // OSG_NOTICE<<" after clamp pm="<<pm<<std::endl; 
    1447          
     1447 
    14481448        osg::Matrix MVP = *(cv->getModelViewMatrix()) * pm; 
    14491449        osg::Matrix inverseMVP; 
     
    14581458#endif 
    14591459        frustum.transform(inverseMVP, MVP); 
    1460          
     1460 
    14611461 
    14621462        // create polytope for the overlay subgraph in local coords 
    14631463        CustomPolytope overlayPolytope; 
    14641464 
    1465         // get the bounds of the model.     
     1465        // get the bounds of the model. 
    14661466        osg::ComputeBoundsVisitor cbbv(osg::NodeVisitor::TRAVERSE_ACTIVE_CHILDREN); 
    14671467        _overlaySubgraph->accept(cbbv); 
    14681468        overlayPolytope.setToBoundingBox(cbbv.getBoundingBox()); 
    1469          
     1469 
    14701470        if (em) 
    14711471        { 
     
    14771477        } 
    14781478 
    1479          
     1479 
    14801480        if (overlayData._geode.valid() && overlayData._geode->getNumDrawables()>100) 
    14811481        { 
    14821482            overlayData._geode->removeDrawables(0, 3); 
    1483         }         
     1483        } 
    14841484 
    14851485        if (overlayData._geode.valid()) 
     
    14891489        } 
    14901490 
    1491          
     1491 
    14921492 
    14931493 
     
    14951495        // OSG_NOTICE<<"AFTER CUT corners = "<<corners.size()<<std::endl; 
    14961496 
    1497   
     1497 
    14981498        osg::Vec3d center = _overlaySubgraph->getBound().center(); 
    1499          
     1499 
    15001500        osg::Vec3d lookVector(0.0,0.0,-1.0); 
    15011501        if (em) 
     
    15071507        osg::Vec3d sideVectorLV = lookVector ^ cv->getLookVectorLocal(); 
    15081508        osg::Vec3d sideVectorUP = lookVector ^ cv->getUpLocal(); 
    1509          
     1509 
    15101510        osg::Vec3d sideVector = sideVectorLV.length() > sideVectorUP.length() ? 
    15111511            sideVectorLV : 
    15121512            sideVectorUP; 
    1513          
     1513 
    15141514        sideVector.normalize(); 
    1515          
     1515 
    15161516        osg::Vec3d upVector = sideVector ^ lookVector; 
    15171517        upVector.normalize(); 
    1518      
     1518 
    15191519        osg::Vec3d overlayLookVector = upVector ^ sideVector; 
    15201520        overlayLookVector.normalize(); 
    1521          
    1522          
     1521 
     1522 
    15231523        overlayPolytope.cut(frustum); 
    15241524 
     
    15411541            overlayData._geode->addDrawable(overlayPolytope.createDrawable(osg::Vec4d(1.0f,1.0f,1.0f,1.0f))); 
    15421542        } 
    1543          
     1543 
    15441544 
    15451545        // OSG_NOTICE<<"    lookVector ="<<lookVector<<std::endl; 
    1546          
     1546 
    15471547        double min_side = DBL_MAX; 
    15481548        double max_side = -DBL_MAX; 
     
    15571557        typedef std::vector<osg::Vec2d> ProjectedVertices; 
    15581558        ProjectedVertices projectedVertices; 
    1559          
     1559 
    15601560        osg::Vec3 eyeLocal = cv->getEyeLocal(); 
    1561          
     1561 
    15621562 
    15631563        // computed the expected near/far ratio 
     
    15851585            if (distance_up>max_up) max_up = distance_up; 
    15861586        } 
    1587                  
     1587 
    15881588        double mid_side = (min_side + max_side) * 0.5; 
    15891589        double ratio = min_distanceEye / max_distanceEye; 
     
    16071607                if (side_over_up > max_side_over_up) max_side_over_up = side_over_up; 
    16081608            } 
    1609             osg::Vec3d v000 = osg::Vec3d(-1.0, -1.0, -1.0) * inverseMVP;  
    1610             osg::Vec3d v010 = osg::Vec3d(-1.0, 1.0, -1.0) * inverseMVP;  
    1611             osg::Vec3d v100 = osg::Vec3d(1.0, -1.0, -1.0) * inverseMVP;  
    1612             osg::Vec3d v110 = osg::Vec3d(1.0, 1.0, -1.0) * inverseMVP;  
    1613  
    1614             osg::Vec3d v001 = osg::Vec3d(-1.0, -1.0, 1.0) * inverseMVP;  
    1615             osg::Vec3d v011 = osg::Vec3d(-1.0, 1.0, 1.0) * inverseMVP;  
    1616             osg::Vec3d v101 = osg::Vec3d(1.0, -1.0, 1.0) * inverseMVP;  
    1617             osg::Vec3d v111 = osg::Vec3d(1.0, 1.0, 1.0) * inverseMVP;  
     1609            osg::Vec3d v000 = osg::Vec3d(-1.0, -1.0, -1.0) * inverseMVP; 
     1610            osg::Vec3d v010 = osg::Vec3d(-1.0, 1.0, -1.0) * inverseMVP; 
     1611            osg::Vec3d v100 = osg::Vec3d(1.0, -1.0, -1.0) * inverseMVP; 
     1612            osg::Vec3d v110 = osg::Vec3d(1.0, 1.0, -1.0) * inverseMVP; 
     1613 
     1614            osg::Vec3d v001 = osg::Vec3d(-1.0, -1.0, 1.0) * inverseMVP; 
     1615            osg::Vec3d v011 = osg::Vec3d(-1.0, 1.0, 1.0) * inverseMVP; 
     1616            osg::Vec3d v101 = osg::Vec3d(1.0, -1.0, 1.0) * inverseMVP; 
     1617            osg::Vec3d v111 = osg::Vec3d(1.0, 1.0, 1.0) * inverseMVP; 
    16181618 
    16191619 
     
    16261626            edgeTopLeft.normalize(); 
    16271627            edgeTopRight.normalize(); 
    1628              
    1629             
     1628 
     1629 
    16301630            double frustumDiagonal = osg::RadiansToDegrees(acos(edgeBottomLeft * edgeBottomRight)); 
    1631              
    1632              
     1631 
     1632 
    16331633            //OSG_NOTICE<<"  width ratio  = "<<new_width/original_width<<std::endl; 
    16341634            //OSG_NOTICE<<"  near ratio  = "<<ratio * new_width/original_width<<std::endl; 
     
    16391639            { 
    16401640                double maxHalfAngle = osg::DegreesToRadians(30.0); 
    1641                  
     1641 
    16421642                // move ratio back 
    16431643                max_side_over_up = tan(maxHalfAngle); 
    16441644                double lowest_up = min_up; 
    1645                  
     1645 
    16461646                for(i=0; i< projectedVertices.size(); ++i) 
    16471647                { 
    16481648                    double delta_side = fabs(projectedVertices[i].x() - mid_side); 
    1649                     double delta_up = delta_side / max_side_over_up;                     
     1649                    double delta_up = delta_side / max_side_over_up; 
    16501650                    double local_base_up = projectedVertices[i].y() - delta_up; 
    16511651                    if (local_base_up < lowest_up) 
     
    16551655                    } 
    16561656                } 
    1657                  
     1657 
    16581658                double new_ratio = (min_up-lowest_up)/(max_up-lowest_up); 
    1659                  
     1659 
    16601660                //OSG_NOTICE<<"  originalRatio  = "<<ratio<<" new_ratio="<<new_ratio<<std::endl; 
    1661                  
     1661 
    16621662                if (new_ratio > ratio) ratio = new_ratio; 
    1663                  
     1663 
    16641664                base_up = lowest_up; 
    16651665 
     
    16691669            min_side = mid_side - max_half_width; 
    16701670            max_side = mid_side + max_half_width; 
    1671              
     1671 
    16721672//            double new_width = max_side-min_side; 
    16731673 
    1674          
     1674 
    16751675            double y0 = (1.0 + ratio) / (1.0 - ratio); 
    16761676            overlayData._y0->set(static_cast<float>(y0)); 
    1677              
     1677 
    16781678 
    16791679            // OSG_NOTICE<<"y0 = "<<y0<<std::endl; 
    1680          
     1680 
    16811681            overlayData._mainSubgraphStateSet->setAttribute(overlayData._mainSubgraphProgram.get()); 
    1682              
     1682 
    16831683            osg::Matrixd projection; 
    16841684            projection.makeOrtho(min_side,max_side,min_up,max_up,zNear ,zFar); 
    16851685 
    16861686            camera->setProjectionMatrix(projection); 
    1687              
     1687 
    16881688        } 
    16891689        else 
     
    16971697        double width = max_side-min_side; 
    16981698        double height = max_up-min_up; 
    1699         double area = width*height;         
     1699        double area = width*height; 
    17001700 
    17011701        OSG_NOTICE<<"width = "<<width<<"\t height = "<<height<<"\t area = "<<area<<std::endl; 
     
    17061706        OSG_NOTICE<<"a  max_up  = "<<max_up<<std::endl; 
    17071707#endif 
    1708              
     1708 
    17091709        if (em) 
    17101710        { 
     
    17391739        { 
    17401740            cv->pushStateSet(overlayData._overlayStateSet.get()); 
    1741              
     1741 
    17421742            typedef std::list<const osg::StateSet*> StateSetStack; 
    17431743            StateSetStack statesetStack; 
    1744              
     1744 
    17451745            osgUtil::StateGraph* sg = cv->getCurrentStateGraph(); 
    17461746            while(sg) 
     
    17501750                { 
    17511751                    statesetStack.push_front(stateset); 
    1752                 }                 
     1752                } 
    17531753                sg = sg->_parent; 
    17541754            } 
    1755              
     1755 
    17561756            osg::StateAttribute::GLModeValue base_mode = osg::StateAttribute::ON; 
    17571757            for(StateSetStack::iterator itr = statesetStack.begin(); 
     
    17691769                } 
    17701770            } 
    1771              
     1771 
    17721772            overlayData._lightingEnabled->set((base_mode & osg::StateAttribute::ON)!=0); 
    17731773        } 
    1774          
     1774 
    17751775        // if we need to redraw then do cull traversal on camera. 
    17761776        camera->setClearColor(_overlayClearColor); 
     
    17921792    else 
    17931793    { 
    1794         Group::traverse(nv);     
    1795     } 
    1796      
     1794        Group::traverse(nv); 
     1795    } 
     1796 
    17971797    // OSG_NOTICE<<"   "<<&overlayData<<std::endl; 
    17981798} 
     
    18511851    if (_textureSizeHint == size) return; 
    18521852 
    1853     _textureSizeHint = size;     
     1853    _textureSizeHint = size; 
    18541854 
    18551855 
     
    18771877 
    18781878        osg::StateSet* mainSubgraphStateSet = itr->second->_mainSubgraphStateSet.get(); 
    1879         if (mainSubgraphStateSet)   
     1879        if (mainSubgraphStateSet) 
    18801880        { 
    18811881            mainSubgraphStateSet->clear(); 
     
    18861886            mainSubgraphStateSet->setTextureMode(_textureUnit, GL_TEXTURE_GEN_Q, osg::StateAttribute::ON); 
    18871887 
    1888             if (_texEnvMode!=GL_NONE)  
     1888            if (_texEnvMode!=GL_NONE) 
    18891889            { 
    18901890                mainSubgraphStateSet->setTextureAttribute(_textureUnit, new osg::TexEnv((osg::TexEnv::Mode)_texEnvMode));