Source/Contrib/WebInterface/testWebInterface.cpp

   1 #include "OSGConfig.h"
   2
   3 #include <iostream>
   4
   5 #include "OSGGLUT.h"
   6
   7 #include "OSGFieldContainerFactory.h"
   8 #include "OSGVector.h"
   9 #include "OSGQuaternion.h"
  10 #include "OSGMatrix.h"
  11 #include "OSGMatrixUtility.h"
  12 #include "OSGBoxVolume.h"
  13 #include "OSGLine.h"
  14 #include "OSGNode.h"
  15 #include "OSGGroup.h"
  16 #include "OSGThread.h"
  17 #include "OSGTransform.h"
  18 #include "OSGAction.h"
  19 #include "OSGRenderAction.h"
  20 #include "OSGSimpleGeometry.h"
  21 #include "OSGSceneFileHandler.h"
  22 #include "OSGChunkOverrideGroup.h"
  23 #include "OSGPolygonChunk.h"
  24 #include "OSGDirectionalLight.h"
  25
  26 #include "OSGViewport.h"
  27 #include "OSGCamera.h"
  28 #include "OSGWindow.h"
  29 #include "OSGGLUTWindow.h"
  30 #include "OSGCamera.h"
  31 #include "OSGPerspectiveCamera.h"
  32 #include "OSGSolidBackground.h"
  33 //#include "OSGUniformBackground.h"
  34 #include "OSGOSGWriter.h"
  35 #include "OSGChangeList.h"
  36 #include "OSGIOStream.h"
  37 #include "OSGGeoFunctions.h"
  38 #include "OSGGraphOp.h"
  39 #include "OSGGraphOpFactory.h"
  40 #include "OSGMultiCore.h"
  41 #include "OSGFrameHandler.h"
  42 #include "OSGWebInterface.h"
  43
  44 #include "OSGTrackball.h"
  45
  46 OSG::RenderActionRefPtr rentravact;
  47
  48 OSG::NodeRecPtr  root;
  49
  50 //OSG::NodeRecPtr  file;
  51
  52 OSG::PerspectiveCameraRecPtr cam;
  53 OSG::ViewportRecPtr vp;
  54 OSG::WindowRecPtr win;
  55
  56 OSG::TransformRecPtr cam_trans;
  57 OSG::TransformRecPtr scene_trans;
  58
  59 OSG::PolygonChunkRecPtr       pPoly;
  60 bool                     bPolyActive = false;
  61 OSG::ChunkOverrideGroupRecPtr pCOver;
  62
  63 OSG::GLUTWindowUnrecPtr gwin;
  64
  65 OSG::Trackball tball;
  66
  67 bool move_obj = false;
  68
  69 int mouseb = 0;
  70 int lastx=0, lasty=0;
  71
  72 OSG::Quaternion oldq;
  73 OSG::Vec3f      oldv;
  74
  75 OSG::WebInterfaceRefPtr webInterface;
  76
  77 void
  78 display(void)
  79 {
  80     OSG::Matrix m1, m2, m3;
  81     OSG::Quaternion q1;
  82
  83     tball.getRotation().getValue(m3);
  84
  85     q1.setValue(m3);
  86
  87     m1.setRotate(q1);
  88
  89 //    std::cout << "TBROT" << std::endl << tball.getRotation() << endl;
  90 //    std::cout << "M3" << std::endl << m3 << std::endl;
  91 //    std::cout << "Q1" << std::endl << q1 << std::endl;
  92 //    std::cout << "M1" << std::endl << m1 << std::endl;
  93
  94 //  m1.setRotate( tball.getRotation() );
  95     m2.setTranslate( tball.getPosition() );
  96
  97 //std::cout << "Pos: " << tball.getPosition() << ", Rot: " << tball.getRotation() << std::endl;
  98
  99 //    std::cout << tball.getRotation() << std::endl;
 100
 101     m1.mult( m2 );
 102
 103 //    std::cerr << m1 << std::endl;
 104
 105     m1 = tball.getFullTrackballMatrix();
 106
 107     if(move_obj == true)
 108     {
 109         scene_trans->editSFMatrix()->setValue( m1 );
 110     }
 111     else
 112     {
 113         cam_trans->editSFMatrix()->setValue( m1 );
 114     }
 115
 116     OSG::FrameHandler::the()->frame();
 117
 118     OSG::commitChanges();
 119
 120     win->render(rentravact);
 121
 122     webInterface->waitRequest(0.01);
 123     webInterface->handleRequests();
 124
 125 //    win->render(renact);
 126
 127 //    std::cerr << "------------- AR START --------------" << std::endl;
 128
 129 //    Thread::getCurrentChangeList()->dump();
 130 }
 131
 132 void reshape( int w, int h )
 133 {
 134     std::cerr << "Reshape: " << w << "," << h << std::endl;
 135     win->resize( w, h );
 136 }
 137
 138
 139 void
 140 animate(void)
 141 {
 142     glutPostRedisplay();
 143 }
 144
 145 // tballall stuff
 146
 147
 148 void
 149 motion(int x, int y)
 150 {
 151     OSG::Real32 w = win->getWidth(), h = win->getHeight();
 152
 153
 154     OSG::Real32  a = -2. * ( lastx / w - .5 ),
 155                  b = -2. * ( .5 - lasty / h ),
 156                  c = -2. * ( x / w - .5 ),
 157                  d = -2. * ( .5 - y / h );
 158
 159     if ( mouseb & ( 1 << GLUT_LEFT_BUTTON ) )
 160     {
 161         tball.updateRotation( a, b, c, d );
 162     }
 163     else if ( mouseb & ( 1 << GLUT_MIDDLE_BUTTON ) )
 164     {
 165         tball.updatePosition( a, b, c, d );
 166     }
 167     else if ( mouseb & ( 1 << GLUT_RIGHT_BUTTON ) )
 168     {
 169         tball.updatePositionNeg( a, b, c, d );
 170     }
 171     lastx = x;
 172     lasty = y;
 173 }
 174
 175 void
 176 mouse(int button, int state, int x, int y)
 177 {
 178     if ( state == 0 )
 179     {
 180         switch ( button )
 181         {
 182         case GLUT_LEFT_BUTTON:  break;
 183         case GLUT_MIDDLE_BUTTON:tball.setAutoPosition(true);
 184                                 break;
 185         case GLUT_RIGHT_BUTTON:     tball.setAutoPositionNeg(true);
 186                                 break;
 187         }
 188         mouseb |= 1 << button;
 189     }
 190     else if ( state == 1 )
 191     {
 192         switch ( button )
 193         {
 194         case GLUT_LEFT_BUTTON:  break;
 195         case GLUT_MIDDLE_BUTTON:tball.setAutoPosition(false);
 196                                 break;
 197         case GLUT_RIGHT_BUTTON:     tball.setAutoPositionNeg(false);
 198                                 break;
 199         }
 200         mouseb &= ~(1 << button);
 201     }
 202     lastx = x;
 203     lasty = y;
 204 }
 205
 206 void
 207 vis(int visible)
 208 {
 209     if (visible == GLUT_VISIBLE)
 210     {
 211         glutIdleFunc(animate);
 212     }
 213     else
 214     {
 215         glutIdleFunc(NULL);
 216     }
 217 }
 218
 219 void key(unsigned char key, int x, int y)
 220 {
 221     switch ( key )
 222     {
 223         case 27:
 224             OSG::FrameHandler::the()->shutdown();
 225
 226             root         = NULL;
 227 //            file         = NULL;
 228             cam          = NULL;
 229             vp           = NULL;
 230             win          = NULL;
 231             cam_trans    = NULL;
 232             scene_trans  = NULL;
 233             pPoly        = NULL;
 234             pCOver       = NULL;
 235             gwin         = NULL;
 236
 237             webInterface = NULL;
 238             rentravact   = NULL;
 239
 240             OSG::osgExit();
 241
 242             exit(0);
 243         case 'v':
 244             rentravact->setVolumeDrawing(!rentravact->getVolumeDrawing());
 245         case 'a':
 246             glDisable( GL_LIGHTING );
 247             std::cerr << "Lighting disabled." << std::endl;
 248             break;
 249         case 's':
 250             glEnable( GL_LIGHTING );
 251             std::cerr << "Lighting enabled." << std::endl;
 252             break;
 253         case 'z':
 254             pPoly->setFrontMode(GL_POINT);
 255             pPoly->setBackMode(GL_POINT);
 256             std::cerr << "PolygonMode: Point." << std::endl;
 257             break;
 258         case 'x':
 259             pPoly->setFrontMode(GL_LINE);
 260             pPoly->setBackMode(GL_LINE);
 261             std::cerr << "PolygonMode: Line." << std::endl;
 262             break;
 263         case 'c':
 264             pPoly->setFrontMode(GL_FILL);
 265             pPoly->setBackMode(GL_FILL);
 266             std::cerr << "PolygonMode: Fill." << std::endl;
 267             break;
 268         case 'p':
 269         {
 270             if(bPolyActive == true)
 271             {
 272                 OSG_ASSERT(pCOver->subChunk(pPoly) == true);
 273                 bPolyActive = false;
 274             }
 275             else
 276             {
 277                 OSG_ASSERT(pCOver->addChunk(pPoly) == true);
 278                 bPolyActive = true;
 279             }
 280             break;
 281         }
 282         case 'r':
 283         {
 284             std::cerr << "Sending ray through " << x << "," << y << std::endl;
 285             OSG::Line l;
 286             cam->calcViewRay( l, x, y, *vp );
 287             std::cerr << "From " << l.getPosition() << ", dir "
 288                       << l.getDirection()
 289                       << std::endl;
 290         }
 291         break;
 292
 293         case ' ':
 294         {
 295             OSG::Matrix     m;
 296             OSG::Quaternion q;
 297             OSG::Vec3f      v;
 298
 299             q = oldq;
 300             v = oldv;
 301
 302             oldq = tball.getRotation();
 303             oldv = tball.getPosition();
 304
 305             move_obj = ! move_obj;
 306             if ( move_obj )
 307             {
 308                 puts("moving object");
 309 //                m = scene_trans->getSFMatrix()->getValue();
 310                 tball.setMode( OSG::Trackball::OSGCamera );
 311
 312             }
 313             else
 314             {
 315                 puts("moving camera");
 316 //                m = cam_trans->getSFMatrix()->getValue();
 317                 tball.setMode( OSG::Trackball::OSGObject );
 318             }
 319
 320 //            q.setValue(m);
 321             tball.setStartPosition( v, true );
 322             tball.setStartRotation( q, true );
 323
 324 //            std::cout << q << std::endl;
 325 //            std::cout << v << std::endl;
 326
 327 //            std::cout << " " << m[3][0] << " " << m[3][1] << " " << m[3][2] << std::endl;
 328
 329         }
 330         break;
 331     }
 332 }
 333
 334
 335 int init(int argc, char **argv)
 336 {
 337     OSG::osgInit(argc,argv);
 338
 339     OSG::setVBOUsageOnPropertyProtos(true);
 340
 341     // GLUT init
 342
 343     glutInit(&argc, argv);
 344     glutInitDisplayMode( GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE);
 345     int winid = glutCreateWindow("OpenSG");
 346     glutKeyboardFunc(key);
 347     glutVisibilityFunc(vis);
 348     glutReshapeFunc(reshape);
 349     glutDisplayFunc(display);
 350     glutMouseFunc(mouse);
 351     glutMotionFunc(motion);
 352
 353     glutIdleFunc(display);
 354
 355     // glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
 356
 357 //    glEnable( GL_DEPTH_TEST );
 358 //    glEnable( GL_LIGHTING );
 359 //    glEnable( GL_LIGHT0 );
 360 //    glFrontFace(GL_CW);
 361 //    glEnable(GL_CULL_FACE);
 362
 363     // OSG
 364
 365     OSG::SceneFileHandler::the()->print();
 366
 367     // create the graph
 368
 369     // beacon for camera and light
 370     OSG::NodeUnrecPtr b1n = OSG::Node::create();
 371     OSG::GroupUnrecPtr b1 = OSG::Group::create();
 372
 373     b1n->setCore( b1 );
 374
 375     // transformation
 376     OSG::NodeUnrecPtr t1n = OSG::Node::create();
 377     OSG::TransformUnrecPtr t1 = OSG::Transform::create();
 378
 379     t1n->setCore( t1 );
 380     t1n->addChild( b1n );
 381
 382     cam_trans = t1;
 383
 384     // light
 385
 386     OSG::NodeUnrecPtr dlight = OSG::Node::create();
 387     OSG::DirectionalLightUnrecPtr dl = OSG::DirectionalLight::create();
 388
 389     dlight->setCore( dl );
 390 //    dlight->setCore( Group::create() );
 391
 392     dl->setAmbient( .0, .0, .0, 1 );
 393     dl->setDiffuse( .8f, .8f, .8f, 1.f );
 394     dl->setDirection(0,0,1);
 395     dl->setBeacon( b1n);
 396
 397     // root
 398     root = OSG::Node::create();
 399     OSG::GroupUnrecPtr gr1 = OSG::Group::create();
 400
 401     root->setCore( gr1 );
 402     root->addChild( t1n );
 403     root->addChild( dlight );
 404
 405     // Load the file
 406
 407     OSG::NodeUnrecPtr file = NULL;
 408
 409     if(argc > 1)
 410         file = OSG::SceneFileHandler::the()->read(argv[1], NULL, NULL);
 411
 412     if ( file == NULL )
 413     {
 414         std::cerr << "Couldn't load file, ignoring" << std::endl;
 415
 416         file = OSG::makeSphere(4, 2.0);
 417
 418     }
 419
 420     OSG::Thread::getCurrentChangeList()->commitChanges();
 421
 422 #if 0
 423     OSG::GeometryPtr pGeo = cast_dynamic<OSG::GeometryPtr>(file->getCore());
 424
 425     if(pGeo == NULL && file->getNChildren() != 0)
 426     {
 427         pGeo = cast_dynamic<OSG::GeometryPtr>(file->getChild(0)->getCore());
 428     }
 429
 430     if(pGeo == NULL)
 431     {
 432         fprintf(stderr, "no geo\n");
 433     }
 434 #endif
 435
 436     OSG::GraphOpRefPtr op = OSG::GraphOpFactory::the()->create("Stripe");
 437
 438 //    op->traverse(file);
 439 //   createOptimizedPrimitives(pGeo);
 440 //    createSharedIndex(pGeo);
 441
 442
 443 //    file->dump();
 444     file->updateVolume();
 445
 446 #if 0
 447     const char *outFileName = "/tmp/foo1.osg";
 448
 449     OSG::IndentFileOutStream outFileStream(outFileName);
 450
 451     if( !outFileStream )
 452     {
 453         std::cerr << "Can not open output stream to file: "
 454                   << outFileName << std::endl;
 455         return -1;
 456     }
 457
 458     std::cerr << "STARTING PRINTOUT:" << std::endl;
 459     OSG::OSGWriter writer( outFileStream, 4 );
 460
 461     writer.write( file );
 462
 463     outFileStream.close();
 464
 465     OSG::SceneFileHandler::the()->write(file, "/tmp/foo.osb");
 466 #endif
 467
 468
 469 //    return 0;
 470
 471
 472     OSG::Vec3f min,max;
 473     file->getVolume().getBounds( min, max );
 474
 475
 476     std::cout << "Volume: from " << min << " to " << max << std::endl;
 477
 478
 479 //    NodePtr pChunkOverNode = Node::create();
 480
 481
 482 //    pChunkOverNode->setCore(pCOver);
 483 //    pChunkOverNode->addChild(file);
 484
 485     OSG::MultiCoreUnrecPtr pMCore = OSG::MultiCore::create();
 486
 487     pCOver      = OSG::ChunkOverrideGroup::create();
 488     scene_trans = OSG::Transform::create();
 489
 490     pMCore->addCore(scene_trans);
 491     pMCore->addCore(pCOver     );
 492
 493     OSG::NodeUnrecPtr sceneTrN = OSG::Node::create();
 494
 495     sceneTrN->setCore(pMCore);
 496     sceneTrN->addChild(file);
 497
 498
 499     dlight->addChild(sceneTrN);
 500
 501     std::cerr << "Tree: " << std::endl;
 502 //  root->dump();
 503
 504     // Camera
 505
 506     cam = OSG::PerspectiveCamera::create();
 507
 508     cam->setBeacon( b1n );
 509     cam->setFov( OSG::osgDegree2Rad( 90 ) );
 510     cam->setNear( 0.1f );
 511     cam->setFar( 10000 );
 512
 513     // Background
 514     OSG::SolidBackgroundUnrecPtr bkgnd = OSG::SolidBackground::create();
 515
 516     bkgnd->setColor(OSG::Color3f(0.1,0.1,0.1));
 517
 518     // Viewport
 519
 520     vp = OSG::Viewport::create();
 521
 522     vp->setCamera( cam );
 523     vp->setBackground( bkgnd );
 524     vp->setRoot( root );
 525     vp->setSize( 0,0, 1,1 );
 526
 527 //    vp->dump();
 528
 529     // Window
 530     std::cout << "GLUT winid: " << winid << std::endl;
 531
 532
 533     GLint glvp[4];
 534
 535     glGetIntegerv( GL_VIEWPORT, glvp );
 536
 537     gwin = OSG::GLUTWindow::create();
 538     gwin->setGlutId(winid);
 539     gwin->setSize( glvp[2], glvp[3] );
 540
 541     win = gwin;
 542
 543     win->addPort( vp );
 544
 545     win->init();
 546
 547     // Action
 548
 549     rentravact = OSG::RenderAction::create();
 550 //    renact->setFrustumCulling(false);
 551
 552     rentravact->setCorrectTwoSidedLighting(true);
 553
 554     // tball
 555
 556     OSG::Vec3f pos;
 557     pos.setValues(min[0] + ((max[0] - min[0]) * 0.5),
 558                   min[1] + ((max[1] - min[1]) * 0.5),
 559                   max[2] + ( max[2] - min[2] ) * 1.5 );
 560
 561     float scale = (max[2] - min[2] + max[1] - min[1] + max[0] - min[0]) / 6;
 562
 563     OSG::Pnt3f tCenter(min[0] + (max[0] - min[0]) / 2,
 564                        min[1] + (max[1] - min[1]) / 2,
 565                        min[2] + (max[2] - min[2]) / 2);
 566
 567     fprintf(stderr, "Startpos : %f %f %f\n", pos[0], pos[1], pos[2]);
 568
 569     tball.setMode( OSG::Trackball::OSGObject );
 570     tball.setStartPosition( pos, true );
 571     tball.setSum( true );
 572     tball.setTranslationMode( OSG::Trackball::OSGFree );
 573     tball.setTranslationScale(scale);
 574     tball.setRotationCenter(tCenter);
 575
 576     fprintf(stderr, "%d\n",
 577             OSG::MFUnrecNodePtr          ::getClassType().getId());
 578     fprintf(stderr, "%d\n",
 579             OSG::MFUnrecFieldContainerPtr::getClassType().getId());
 580
 581 //    MFNodePtr          ::getClassType().dump();
 582 //    MFFieldContainerPtr::getClassType().dump();
 583
 584     // run...
 585
 586     pPoly = OSG::PolygonChunk::create();
 587
 588     pCOver->subChunk(pPoly);
 589
 590 #if 0
 591     GroupNodePtr pGr = GroupNodePtr::create();
 592
 593     NodePtr  pN;
 594     GroupPtr pG;
 595
 596     fprintf(stderr, "A\n");
 597
 598     if(pGr == NULL)
 599     {
 600     }
 601
 602     fprintf(stderr, "B\n");
 603
 604     if(pGr == pN)
 605     {
 606     }
 607
 608     fprintf(stderr, "C\n");
 609
 610     if(pGr == pG)
 611     {
 612     }
 613
 614     pGr = NULL;
 615 #endif
 616
 617     OSG::FrameHandler::the()->init();
 618
 619
 620     webInterface = OSG::WebInterface::create();
 621     webInterface->setRoot(root);
 622
 623     return 0;
 624 }
 625
 626 int main (int argc, char **argv)
 627 {
 628     init(argc, argv);
 629
 630     glutMainLoop();
 631
 632     return 0;
 633 }
 634