Show
Ignore:
Timestamp:
04/14/14 18:16:22 (9 days ago)
Author:
robert
Message:

Fixed comment

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • OpenSceneGraph/trunk/examples/osgcluster/osgcluster.cpp

    r11624 r13890  
    4949class CameraPacket { 
    5050    public: 
    51      
    52      
    53         CameraPacket():_masterKilled(false)  
     51 
     52 
     53        CameraPacket():_masterKilled(false) 
    5454        { 
    5555            _byte_order = SWAP_BYTES_COMPARE; 
    5656        } 
    57          
     57 
    5858        void setPacket(const osg::Matrix& matrix,const osg::FrameStamp* frameStamp) 
    5959        { 
     
    6464            } 
    6565        } 
    66          
     66 
    6767        void getModelView(osg::Matrix& matrix,float angle_offset=0.0f) 
    6868        { 
    69          
     69 
    7070            matrix = _matrix * osg::Matrix::rotate(osg::DegreesToRadians(angle_offset),0.0f,1.0f,0.0f); 
    7171        } 
    72          
     72 
    7373        void readEventQueue(osgViewer::Viewer& viewer); 
    74          
     74 
    7575        void writeEventQueue(osgViewer::Viewer& viewer); 
    7676 
    7777        void setMasterKilled(const bool flag) { _masterKilled = flag; } 
    7878        const bool getMasterKilled() const { return _masterKilled; } 
    79          
     79 
    8080        unsigned int    _byte_order; 
    8181        bool            _masterKilled; 
     
    8585        // since we don't want to copy the pointer - but the memory. 
    8686        // FrameStamp doesn't have a private destructor to allow 
    87         // us to do this, even though its a reference counted object.     
     87        // us to do this, even though its a reference counted object. 
    8888        osg::FrameStamp  _frameStamp; 
    89          
     89 
    9090        osgGA::EventQueue::Events _events; 
    91          
     91 
    9292}; 
    9393 
     
    113113 
    114114        char* _currentPtr; 
    115          
     115 
    116116        void reset() 
    117117        { 
     
    123123            if (_currentPtr+1>=_endPtr) return; 
    124124 
    125             *(_currentPtr++) = *(ptr);  
     125            *(_currentPtr++) = *(ptr); 
    126126        } 
    127127 
     
    130130            if (_currentPtr+1>=_endPtr) return; 
    131131 
    132             *(ptr) = *(_currentPtr++);  
     132            *(ptr) = *(_currentPtr++); 
    133133        } 
    134134 
     
    137137            if (_currentPtr+2>=_endPtr) return; 
    138138 
    139             *(_currentPtr++) = *(ptr++);  
    140             *(_currentPtr++) = *(ptr);  
     139            *(_currentPtr++) = *(ptr++); 
     140            *(_currentPtr++) = *(ptr); 
    141141        } 
    142142 
     
    147147            if (_swapBytes) 
    148148            { 
    149                 *(ptr+1) = *(_currentPtr++);  
    150                 *(ptr) = *(_currentPtr++);  
     149                *(ptr+1) = *(_currentPtr++); 
     150                *(ptr) = *(_currentPtr++); 
    151151            } 
    152152            else 
    153153            { 
    154                 *(ptr++) = *(_currentPtr++);  
    155                 *(ptr) = *(_currentPtr++);  
     154                *(ptr++) = *(_currentPtr++); 
     155                *(ptr) = *(_currentPtr++); 
    156156            } 
    157157        } 
     
    161161            if (_currentPtr+4>=_endPtr) return; 
    162162 
    163             *(_currentPtr++) = *(ptr++);  
    164             *(_currentPtr++) = *(ptr++);  
    165             *(_currentPtr++) = *(ptr++);  
    166             *(_currentPtr++) = *(ptr);  
     163            *(_currentPtr++) = *(ptr++); 
     164            *(_currentPtr++) = *(ptr++); 
     165            *(_currentPtr++) = *(ptr++); 
     166            *(_currentPtr++) = *(ptr); 
    167167        } 
    168168 
     
    173173            if (_swapBytes) 
    174174            { 
    175                 *(ptr+3) = *(_currentPtr++);  
    176                 *(ptr+2) = *(_currentPtr++);  
    177                 *(ptr+1) = *(_currentPtr++);  
    178                 *(ptr) = *(_currentPtr++);  
     175                *(ptr+3) = *(_currentPtr++); 
     176                *(ptr+2) = *(_currentPtr++); 
     177                *(ptr+1) = *(_currentPtr++); 
     178                *(ptr) = *(_currentPtr++); 
    179179            } 
    180180            else 
    181181            { 
    182                 *(ptr++) = *(_currentPtr++);  
    183                 *(ptr++) = *(_currentPtr++);  
    184                 *(ptr++) = *(_currentPtr++);  
    185                 *(ptr) = *(_currentPtr++);  
     182                *(ptr++) = *(_currentPtr++); 
     183                *(ptr++) = *(_currentPtr++); 
     184                *(ptr++) = *(_currentPtr++); 
     185                *(ptr) = *(_currentPtr++); 
    186186            } 
    187187        } 
     
    191191            if (_currentPtr+8>=_endPtr) return; 
    192192 
    193             *(_currentPtr++) = *(ptr++);  
    194             *(_currentPtr++) = *(ptr++);  
    195             *(_currentPtr++) = *(ptr++);  
    196             *(_currentPtr++) = *(ptr++);  
    197  
    198             *(_currentPtr++) = *(ptr++);  
    199             *(_currentPtr++) = *(ptr++);  
    200             *(_currentPtr++) = *(ptr++);  
    201             *(_currentPtr++) = *(ptr);  
     193            *(_currentPtr++) = *(ptr++); 
     194            *(_currentPtr++) = *(ptr++); 
     195            *(_currentPtr++) = *(ptr++); 
     196            *(_currentPtr++) = *(ptr++); 
     197 
     198            *(_currentPtr++) = *(ptr++); 
     199            *(_currentPtr++) = *(ptr++); 
     200            *(_currentPtr++) = *(ptr++); 
     201            *(_currentPtr++) = *(ptr); 
    202202        } 
    203203 
     
    209209            if (_swapBytes) 
    210210            { 
    211                 *(ptr+7) = *(_currentPtr++);  
    212                 *(ptr+6) = *(_currentPtr++);  
    213                 *(ptr+5) = *(_currentPtr++);  
    214                 *(ptr+4) = *(_currentPtr++);  
    215  
    216                 *(ptr+3) = *(_currentPtr++);  
    217                 *(ptr+2) = *(_currentPtr++);  
    218                 *(ptr+1) = *(_currentPtr++);  
    219                 *(ptr) = *(_currentPtr++);  
     211                *(ptr+7) = *(_currentPtr++); 
     212                *(ptr+6) = *(_currentPtr++); 
     213                *(ptr+5) = *(_currentPtr++); 
     214                *(ptr+4) = *(_currentPtr++); 
     215 
     216                *(ptr+3) = *(_currentPtr++); 
     217                *(ptr+2) = *(_currentPtr++); 
     218                *(ptr+1) = *(_currentPtr++); 
     219                *(ptr) = *(_currentPtr++); 
    220220            } 
    221221            else 
    222222            { 
    223                 *(ptr++) = *(_currentPtr++);  
    224                 *(ptr++) = *(_currentPtr++);  
    225                 *(ptr++) = *(_currentPtr++);  
    226                 *(ptr++) = *(_currentPtr++);  
    227  
    228                 *(ptr++) = *(_currentPtr++);  
    229                 *(ptr++) = *(_currentPtr++);  
    230                 *(ptr++) = *(_currentPtr++);  
    231                 *(ptr) = *(_currentPtr++);  
     223                *(ptr++) = *(_currentPtr++); 
     224                *(ptr++) = *(_currentPtr++); 
     225                *(ptr++) = *(_currentPtr++); 
     226                *(ptr++) = *(_currentPtr++); 
     227 
     228                *(ptr++) = *(_currentPtr++); 
     229                *(ptr++) = *(_currentPtr++); 
     230                *(ptr++) = *(_currentPtr++); 
     231                *(ptr) = *(_currentPtr++); 
    232232            } 
    233233        } 
     
    362362            event.setTime(readDouble()); 
    363363        } 
    364          
     364 
    365365        void write(CameraPacket& cameraPacket) 
    366366        { 
    367367            writeUInt(cameraPacket._byte_order); 
    368              
     368 
    369369            writeUInt(cameraPacket._masterKilled); 
    370              
     370 
    371371            write(cameraPacket._matrix); 
    372372            write(cameraPacket._frameStamp); 
    373          
     373 
    374374            writeUInt(cameraPacket._events.size()); 
    375375            for(osgGA::EventQueue::Events::iterator itr = cameraPacket._events.begin(); 
     
    377377                ++itr) 
    378378            { 
    379                 write(*(*itr)); 
     379                osgGA::GUIEventAdapter* event = (*itr)->asGUIEventAdapter(); 
     380                if (event) write(*event); 
    380381            } 
    381382        } 
     
    388389                _swapBytes = !_swapBytes; 
    389390            } 
    390              
     391 
    391392            cameraPacket._masterKilled = readUInt()!=0; 
    392              
     393 
    393394            read(cameraPacket._matrix); 
    394395            read(cameraPacket._frameStamp); 
    395          
     396 
    396397            cameraPacket._events.clear(); 
    397398            unsigned int numEvents = readUInt(); 
     
    410411 
    411412    osgViewer::ViewerBase::Contexts contexts; 
    412     viewer.getContexts(contexts);    
     413    viewer.getContexts(contexts); 
    413414 
    414415    for(osgViewer::ViewerBase::Contexts::iterator citr =contexts.begin();  citr != contexts.end(); ++citr) 
     
    424425        _events.insert(_events.end(), gw_events.begin(), gw_events.end()); 
    425426    } 
    426      
     427 
    427428    viewer.getEventQueue()->copyEvents(_events); 
    428429 
     
    450451    // use an ArgumentParser object to manage the program arguments. 
    451452    osg::ArgumentParser arguments(&argc,argv); 
    452      
     453 
    453454    // set up the usage document, in case we need to print out how to use this program. 
    454455    arguments.getApplicationUsage()->setDescription(arguments.getApplicationName()+" is the example which demonstrates how to approach implementation of clustering."); 
     
    460461    arguments.getApplicationUsage()->addCommandLineOption("-f <float>","Field of view of camera"); 
    461462    arguments.getApplicationUsage()->addCommandLineOption("-o <float>","Offset angle of camera"); 
    462      
     463 
    463464    // construct the viewer. 
    464465    osgViewer::Viewer viewer; 
     
    469470    while (arguments.read("-m")) viewerMode = MASTER; 
    470471    while (arguments.read("-s")) viewerMode = SLAVE; 
    471      
     472 
    472473    int socketNumber=8100; 
    473474    while (arguments.read("-n",socketNumber)) ; 
    474475 
    475476    float camera_fov=-1.0f; 
    476     while (arguments.read("-f",camera_fov))  
     477    while (arguments.read("-f",camera_fov)) 
    477478    { 
    478479    } 
     
    498499        return 1; 
    499500    } 
    500      
     501 
    501502    if (arguments.argc()<=1) 
    502503    { 
     
    515516        double fovy, aspectRatio, zNear, zFar; 
    516517        viewer.getCamera()->getProjectionMatrixAsPerspective(fovy, aspectRatio,zNear, zFar); 
    517          
     518 
    518519        double original_fov = atan(tan(osg::DegreesToRadians(fovy)*0.5)*aspectRatio)*2.0; 
    519520        std::cout << "setting lens perspective : original "<<original_fov<<"  "<<fovy<<std::endl; 
    520          
     521 
    521522        fovy = atan(tan(osg::DegreesToRadians(camera_fov)*0.5)/aspectRatio)*2.0; 
    522523        viewer.getCamera()->setProjectionMatrixAsPerspective(fovy, aspectRatio,zNear, zFar); 
    523      
     524 
    524525        viewer.getCamera()->getProjectionMatrixAsPerspective(fovy, aspectRatio,zNear, zFar); 
    525526        original_fov = atan(tan(osg::DegreesToRadians(fovy)*0.5)*aspectRatio)*2.0; 
     
    550551 
    551552    bool masterKilled = false; 
    552      
     553 
    553554    DataConverter scratchPad(1024); 
    554555 
     
    556557    { 
    557558        osg::Timer_t startTick = osg::Timer::instance()->tick(); 
    558                   
     559 
    559560        viewer.advance(); 
    560561 
     
    564565        case(MASTER): 
    565566            { 
    566                  
     567 
    567568                // take camera zero as the guide. 
    568569                osg::Matrix modelview(viewer.getCamera()->getViewMatrix()); 
    569                  
     570 
    570571                cp->setPacket(modelview,viewer.getFrameStamp()); 
    571                  
     572 
    572573                cp->readEventQueue(viewer); 
    573574 
     
    579580 
    580581                bc.setBuffer(scratchPad._startPtr, scratchPad._numBytes); 
    581                  
     582 
    582583                std::cout << "bc.sync()"<<scratchPad._numBytes<<std::endl; 
    583584 
    584585                bc.sync(); 
    585                  
     586 
    586587            } 
    587588            break; 
     
    592593 
    593594                rc.sync(); 
    594                  
     595 
    595596                scratchPad.reset(); 
    596597                scratchPad.read(*cp); 
    597      
     598 
    598599                cp->writeEventQueue(viewer); 
    599600 
    600                 if (cp->getMasterKilled())  
     601                if (cp->getMasterKilled()) 
    601602                { 
    602603                    std::cout << "Received master killed."<<std::endl; 
     
    610611            break; 
    611612        } 
    612           
     613 
    613614        osg::Timer_t endTick = osg::Timer::instance()->tick(); 
    614          
     615 
    615616        osg::notify(osg::INFO)<<"Time to do cluster sync "<<osg::Timer::instance()->delta_m(startTick,endTick)<<std::endl; 
    616617 
     
    624625            osg::Matrix modelview; 
    625626            cp->getModelView(modelview,camera_offset); 
    626          
     627 
    627628            viewer.getCamera()->setViewMatrix(modelview); 
    628629        } 
     
    631632        if(!masterKilled) 
    632633            viewer.renderingTraversals(); 
    633          
     634 
    634635    } 
    635636 
     
    639640        // need to broadcast my death. 
    640641        cp->setPacket(osg::Matrix::identity(),viewer.getFrameStamp()); 
    641         cp->setMasterKilled(true);  
     642        cp->setMasterKilled(true); 
    642643 
    643644        scratchPad.reset();