| 117 | | // using namespace osgUtil required to get round VisualStudio's inablility |
| 118 | | // to handle osgUtil::SceneView::app() in the code below, only SceneView::app |
| 119 | | // works..but this breaks the IRIX build, unless you have the osgUtil??! |
| 120 | | // Robert Osfield, July 2002. |
| 121 | | using namespace osgUtil; |
| 122 | | |
| 123 | | class MySceneView : public SceneView { |
| 124 | | |
| 125 | | public: |
| 126 | | |
| 127 | | enum ViewerMode |
| 128 | | { |
| 129 | | STAND_ALONE, |
| 130 | | SLAVE, |
| 131 | | MASTER |
| 132 | | }; |
| 133 | | |
| 134 | | MySceneView(ViewerMode viewerMode,int socketNumber,float camera_fov, float camera_offset): |
| 135 | | _viewerMode(viewerMode),_socketNumber(socketNumber), |
| 136 | | _camera_fov(camera_fov), _camera_offset(camera_offset) |
| 137 | | { |
| 138 | | setDefaults(); |
| 139 | | getCamera()->setAdjustAspectRatioMode(osg::Camera::ADJUST_VERTICAL); |
| 140 | | getCamera()->setFOV(camera_fov,camera_fov*(600.0f/800.0f),1.0f,1000.0f); |
| 141 | | |
| 142 | | _bc.setPort(socketNumber); |
| 143 | | _rc.setPort(socketNumber); |
| 144 | | }; |
| 145 | | |
| 146 | | ~MySceneView() |
| 147 | | { |
| 148 | | if (_viewerMode==MASTER) |
| 149 | | { |
| 150 | | // need to broadcast my death. |
| 151 | | CameraPacket cp; |
| 152 | | cp.setPacket(*getCamera(),getFrameStamp()); |
| 153 | | cp.setMasterKilled(true); |
| 154 | | |
| 155 | | _bc.setBuffer(&cp, sizeof( CameraPacket )); |
| 156 | | _bc.sync(); |
| 157 | | |
| 158 | | std::cout << "broadcasting death"<<std::endl; |
| 159 | | |
| 160 | | } |
| 161 | | } |
| 162 | | |
| 163 | | // override the basic SceneView::app traversal. |
| 164 | | virtual void update() |
| 165 | | { |
| 166 | | SceneView::update(); |
| 167 | | switch (_viewerMode) |
| 168 | | { |
| 169 | | case(MASTER): |
| 170 | | { |
| 171 | | CameraPacket cp; |
| 172 | | cp.setPacket(*getCamera(),getFrameStamp()); |
| 173 | | |
| 174 | | _bc.setBuffer(&cp, sizeof( CameraPacket )); |
| 175 | | _bc.sync(); |
| 176 | | |
| 177 | | } |
| 178 | | break; |
| 179 | | case(SLAVE): |
| 180 | | { |
| 181 | | CameraPacket cp; |
| 182 | | |
| 183 | | _rc.setBuffer(&cp, sizeof( CameraPacket )); |
| 184 | | _rc.sync(); |
| 185 | | |
| 186 | | cp.checkByteOrder(); |
| 187 | | |
| 188 | | |
| 189 | | cp.getCamera(*getCamera(),_camera_offset); |
| 190 | | cp.getSceneViewUpdate(*this); |
| 191 | | |
| 192 | | if (cp.getMasterKilled()) |
| 193 | | { |
| 194 | | std::cout << "recieved master killed"<<std::endl; |
| 195 | | _viewerMode = STAND_ALONE; |
| 196 | | } |
| 197 | | } |
| 198 | | break; |
| 199 | | default: |
| 200 | | // no need to anything here, just a normal interactive viewer. |
| 201 | | break; |
| 202 | | } |
| 203 | | } |
| 204 | | |
| 205 | | protected: |
| 206 | | |
| 207 | | ViewerMode _viewerMode; |
| 208 | | int _socketNumber; |
| 209 | | float _camera_fov; |
| 210 | | float _camera_offset; |
| 211 | | unsigned long _byte_order; |
| 212 | | |
| 213 | | |
| 214 | | Broadcaster _bc; |
| 215 | | Receiver _rc; |
| 216 | | |
| 217 | | |
| | 88 | enum ViewerMode |
| | 89 | { |
| | 90 | STAND_ALONE, |
| | 91 | SLAVE, |
| | 92 | MASTER |
| 219 | | |
| 220 | | /* |
| 221 | | * Function to read several files (typically one) as specified on the command |
| 222 | | * line, and return them in an osg::Node |
| 223 | | */ |
| 224 | | osg::Node* getNodeFromFiles(int argc,char **argv, |
| 225 | | MySceneView::ViewerMode& viewerMode, int& socketNumber, |
| 226 | | float& camera_fov, float& camera_offset) |
| 227 | | { |
| 228 | | osg::Node *rootnode = new osg::Node; |
| 229 | | |
| 230 | | int i; |
| 231 | | |
| 232 | | typedef std::vector<osg::Node*> NodeList; |
| 233 | | NodeList nodeList; |
| 234 | | for( i = 1; i < argc; i++ ) |
| 235 | | { |
| 236 | | |
| 237 | | if (argv[i][0]=='-') |
| 238 | | { |
| 239 | | switch(argv[i][1]) |
| 240 | | { |
| 241 | | |
| 242 | | case('m'): |
| 243 | | viewerMode = MySceneView::MASTER; |
| 244 | | break; |
| 245 | | case('s'): |
| 246 | | viewerMode = MySceneView::SLAVE; |
| 247 | | break; |
| 248 | | case('n'): |
| 249 | | ++i; |
| 250 | | if (i<argc) |
| 251 | | { |
| 252 | | socketNumber = atoi(argv[i]); |
| 253 | | } |
| 254 | | break; |
| 255 | | case('f'): |
| 256 | | ++i; |
| 257 | | if (i<argc) |
| 258 | | { |
| 259 | | camera_fov = atoi(argv[i]); |
| 260 | | } |
| 261 | | break; |
| 262 | | case('o'): |
| 263 | | ++i; |
| 264 | | if (i<argc) |
| 265 | | { |
| 266 | | camera_offset = atoi(argv[i]); |
| 267 | | } |
| 268 | | break; |
| 269 | | |
| 270 | | case('l'): |
| 271 | | ++i; |
| 272 | | if (i<argc) |
| 273 | | { |
| 274 | | osgDB::Registry::instance()->loadLibrary(argv[i]); |
| 275 | | } |
| 276 | | break; |
| 277 | | case('e'): |
| 278 | | ++i; |
| 279 | | if (i<argc) |
| 280 | | { |
| 281 | | std::string libName = osgDB::Registry::instance()->createLibraryNameForExt(argv[i]); |
| 282 | | osgDB::Registry::instance()->loadLibrary(libName); |
| 283 | | } |
| 284 | | break; |
| 285 | | } |
| 286 | | } else |
| 287 | | { |
| 288 | | osg::Node *node = osgDB::readNodeFile( argv[i] ); |
| 289 | | |
| 290 | | if( node != (osg::Node *)0L ) |
| 291 | | { |
| 292 | | if (node->getName().empty()) node->setName( argv[i] ); |
| 293 | | nodeList.push_back(node); |
| 294 | | } |
| 295 | | } |
| 296 | | |
| 297 | | } |
| 298 | | |
| 299 | | if (nodeList.size()==0) |
| 300 | | { |
| 301 | | osg::notify(osg::WARN) << "No data loaded."<<std::endl; |
| 302 | | exit(0); |
| 303 | | } |
| 304 | | |
| 305 | | |
| 306 | | /* |
| 307 | | if (master) osg::notify(osg::NOTICE)<<"set to MASTER, broadcasting on socketNumber "<<socketNumber<<std::endl; |
| 308 | | else osg::notify(osg::NOTICE)<<"set to SLAVE, reciving on socketNumber "<<socketNumber<<std::endl; |
| 309 | | |
| 310 | | */ |
| 311 | | |
| 312 | | |
| 313 | | if (nodeList.size()==1) |
| 314 | | { |
| 315 | | rootnode = nodeList.front(); |
| 316 | | } |
| 317 | | else // size >1 |
| 318 | | { |
| 319 | | osg::Group* group = new osg::Group(); |
| 320 | | for(NodeList::iterator itr=nodeList.begin(); |
| 321 | | itr!=nodeList.end(); |
| 322 | | ++itr) |
| 323 | | { |
| 324 | | group->addChild(*itr); |
| 325 | | } |
| 326 | | |
| 327 | | rootnode = group; |
| 328 | | } |
| 329 | | |
| 330 | | return rootnode; |
| 331 | | } |
| 332 | | |
| | 104 | arguments.getApplicationUsage()->addCommandLineOption("-m","Set viewer to MASTER mode, sending view via packets."); |
| | 105 | arguments.getApplicationUsage()->addCommandLineOption("-s","Set viewer to SLAVE mode, reciving view via packets."); |
| | 106 | arguments.getApplicationUsage()->addCommandLineOption("-n <int>","Socket number to transmit packets"); |
| | 107 | arguments.getApplicationUsage()->addCommandLineOption("-f <float>","Field of view of camera"); |
| | 108 | arguments.getApplicationUsage()->addCommandLineOption("-o <float>","Offset angle of camera"); |
| | 119 | |
| | 120 | // read up the osgcluster specific arguments. |
| | 121 | ViewerMode viewerMode = STAND_ALONE; |
| | 122 | while (arguments.read("-m")) viewerMode = MASTER; |
| | 123 | while (arguments.read("-s")) viewerMode = SLAVE; |
| | 124 | |
| | 125 | float socketNumber=8100.0f; |
| | 126 | while (arguments.read("-n",socketNumber)) ; |
| | 127 | |
| | 128 | float camera_fov=45.0f; |
| | 129 | while (arguments.read("-f",camera_fov)) ; |
| | 130 | |
| | 131 | float camera_offset=45.0f; |
| | 132 | while (arguments.read("-o",camera_offset)) ; |
| | 133 | |
| | 134 | |
| 369 | | |
| 370 | | |
| 371 | | osg::Timer timer; |
| 372 | | osg::Timer_t before_load = timer.tick(); |
| 373 | | |
| 374 | | MySceneView::ViewerMode viewerMode = MySceneView::STAND_ALONE; |
| 375 | | int socketNumber=8100; |
| 376 | | float camera_fov=45.0f; |
| 377 | | float camera_offset=45.0f; |
| 378 | | |
| 379 | | osg::Node* rootnode = getNodeFromFiles( argc, argv, viewerMode, socketNumber,camera_fov,camera_offset); |
| 380 | | |
| 381 | | osg::Timer_t after_load = timer.tick(); |
| 382 | | std::cout << "Time for load = "<<timer.delta_s(before_load,after_load)<<" seconds"<<std::endl; |
| 383 | | |
| 384 | | osg::ref_ptr<MySceneView> mySceneView = new MySceneView(viewerMode,socketNumber,camera_fov,osg::inDegrees(camera_offset)); |
| 385 | | mySceneView->setSceneData(rootnode); |
| | 151 | |
| | 152 | |
| | 153 | // load model. |
| | 154 | osg::ref_ptr<osg::Node> rootnode = osgDB::readNodeFiles(arguments); |
| | 155 | |
| | 175 | |
| | 176 | // special handling for working as a cluster. |
| | 177 | switch (viewerMode) |
| | 178 | { |
| | 179 | case(MASTER): |
| | 180 | { |
| | 181 | CameraPacket cp; |
| | 182 | |
| | 183 | // take camera zero as the guide. |
| | 184 | osg::Matrix modelview(viewer.getCameraConfig()->getCamera(0)->getViewMatrix()); |
| | 185 | |
| | 186 | cp.setPacket(modelview,viewer.getFrameStamp()); |
| | 187 | |
| | 188 | bc.setBuffer(&cp, sizeof( CameraPacket )); |
| | 189 | bc.sync(); |
| | 190 | |
| | 191 | } |
| | 192 | break; |
| | 193 | case(SLAVE): |
| | 194 | { |
| | 195 | CameraPacket cp; |
| | 196 | |
| | 197 | rc.setBuffer(&cp, sizeof( CameraPacket )); |
| | 198 | rc.sync(); |
| | 199 | |
| | 200 | cp.checkByteOrder(); |
| | 201 | |
| | 202 | osg::Matrix modelview; |
| | 203 | cp.getModelView(modelview,camera_offset); |
| | 204 | |
| | 205 | viewer.setView(modelview.ptr()); |
| | 206 | |
| | 207 | if (cp.getMasterKilled()) |
| | 208 | { |
| | 209 | std::cout << "recieved master killed"<<std::endl; |
| | 210 | viewerMode = STAND_ALONE; |
| | 211 | } |
| | 212 | } |
| | 213 | break; |
| | 214 | default: |
| | 215 | // no need to anything here, just a normal interactive viewer. |
| | 216 | break; |
| | 217 | } |
| | 218 | |
| | 219 | |