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