Source/System/Window/FrameBufferObjects/testFBOViewport.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 "OSGTextureEnvChunk.h"
  27 #include "OSGTextureObjChunk.h"
  28 #include "OSGSimpleMaterial.h"
  29 #include "OSGPolygonForeground.h"
  30
  31 #include "OSGViewport.h"
  32 #include "OSGCamera.h"
  33 #include "OSGWindow.h"
  34 #include "OSGGLUTWindow.h"
  35 #include "OSGCamera.h"
  36 #include "OSGPerspectiveCamera.h"
  37 #include "OSGSolidBackground.h"
  38 //#include "OSGUniformBackground.h"
  39 #include "OSGOSGWriter.h"
  40 #include "OSGChangeList.h"
  41 #include "OSGIOStream.h"
  42 #include "OSGGeoFunctions.h"
  43 #include "OSGGraphOp.h"
  44 #include "OSGGraphOpFactory.h"
  45 #include "OSGMultiCore.h"
  46
  47 #include "OSGFBOViewport.h"
  48 #include "OSGFrameBufferObject.h"
  49 #include "OSGTextureBuffer.h"
  50 #include "OSGRenderBuffer.h"
  51
  52 #include "OSGTrackball.h"
  53
  54 OSG::RenderActionRefPtr rentravact;
  55
  56 OSG::NodeRecPtr  root;
  57
  58 //OSG::NodeRecPtr  file;
  59
  60 OSG::PerspectiveCameraRecPtr cam;
  61 OSG::ViewportRecPtr vp;
  62 OSG::WindowRecPtr win;
  63
  64 OSG::TransformRecPtr cam_trans;
  65 OSG::TransformRecPtr scene_trans;
  66
  67 OSG::PolygonChunkRecPtr       pPoly;
  68 bool                          bPolyActive = false;
  69 OSG::ChunkOverrideGroupRecPtr pCOver;
  70
  71 OSG::GLUTWindowUnrecPtr gwin;
  72
  73 OSG::TextureObjChunkUnrecPtr tx1o;
  74 OSG::TextureEnvChunkUnrecPtr tx1e;
  75 OSG::FBOViewportUnrecPtr     vpFBO;
  76 OSG::FBOViewportUnrecPtr     vpFBO_RB;
  77 OSG::TextureBufferUnrecPtr   pTexBuffer;
  78 OSG::RenderBufferUnrecPtr    pRenBuffer;
  79 OSG::ImageUnrecPtr           pImg;
  80
  81 OSG::Trackball tball;
  82
  83 bool move_obj = false;
  84
  85 int mouseb = 0;
  86 int lastx=0, lasty=0;
  87
  88 OSG::Quaternion oldq;
  89 OSG::Vec3f      oldv;
  90
  91 OSG::UInt32 oldTravMask;
  92 bool dumpImg = false;
  93
  94 OSG::UInt32 oldTravMask_RB;
  95 bool dumpImg_RB = false;
  96
  97 void display(void)
  98 {
  99     OSG::Matrix m1, m2, m3;
 100     OSG::Quaternion q1;
 101
 102     tball.getRotation().getValue(m3);
 103
 104     q1.setValue(m3);
 105
 106     m1.setRotate(q1);
 107
 108 //    std::cout << "TBROT" << std::endl << tball.getRotation() << endl;
 109 //    std::cout << "M3" << std::endl << m3 << std::endl;
 110 //    std::cout << "Q1" << std::endl << q1 << std::endl;
 111 //    std::cout << "M1" << std::endl << m1 << std::endl;
 112
 113 //  m1.setRotate( tball.getRotation() );
 114     m2.setTranslate( tball.getPosition() );
 115
 116 //std::cout << "Pos: " << tball.getPosition() << ", Rot: " << tball.getRotation() << std::endl;
 117
 118 //    std::cout << tball.getRotation() << std::endl;
 119
 120     m1.mult( m2 );
 121
 122 //    std::cerr << m1 << std::endl;
 123
 124     m1 = tball.getFullTrackballMatrix();
 125
 126     if(move_obj == true)
 127     {
 128         scene_trans->editSFMatrix()->setValue( m1 );
 129     }
 130     else
 131     {
 132         cam_trans->editSFMatrix()->setValue( m1 );
 133     }
 134
 135     OSG::commitChangesAndClear();
 136
 137     win->render(rentravact);
 138
 139     if(dumpImg == true)
 140     {
 141         vpFBO->setTravMask(oldTravMask);
 142
 143         pTexBuffer                   ->setReadBack               (false);
 144         vpFBO->getFrameBufferObject()->setPostProcessOnDeactivate(false);
 145
 146         pImg->write("/tmp/test.png");
 147
 148         dumpImg = false;
 149     }
 150
 151     if(dumpImg_RB == true)
 152     {
 153         pRenBuffer->getImage()->write("/tmp/test1.png");
 154
 155         dumpImg_RB = false;
 156
 157         win->subPortByObj(vpFBO_RB);
 158
 159         vpFBO_RB   = NULL;
 160         pRenBuffer = NULL;
 161
 162         win->runFrameExit();
 163
 164 //        OSG::FieldContainerFactory::the()->dump();
 165     }
 166
 167
 168 //    win->render(renact);
 169
 170 //    std::cerr << "------------- AR START --------------" << std::endl;
 171
 172 //    Thread::getCurrentChangeList()->dump();
 173 }
 174
 175 void reshape( int w, int h )
 176 {
 177     std::cerr << "Reshape: " << w << "," << h << std::endl;
 178     win->resize( w, h );
 179 }
 180
 181
 182 void animate(void)
 183 {
 184     glutPostRedisplay();
 185 }
 186
 187 // tballall stuff
 188
 189
 190 void motion(int x, int y)
 191 {
 192     OSG::Real32 w = win->getWidth(), h = win->getHeight();
 193
 194
 195     OSG::Real32  a = -2. * ( lastx / w - .5 ),
 196                  b = -2. * ( .5 - lasty / h ),
 197                  c = -2. * ( x / w - .5 ),
 198                  d = -2. * ( .5 - y / h );
 199
 200     if ( mouseb & ( 1 << GLUT_LEFT_BUTTON ) )
 201     {
 202         tball.updateRotation( a, b, c, d );
 203     }
 204     else if ( mouseb & ( 1 << GLUT_MIDDLE_BUTTON ) )
 205     {
 206         tball.updatePosition( a, b, c, d );
 207     }
 208     else if ( mouseb & ( 1 << GLUT_RIGHT_BUTTON ) )
 209     {
 210         tball.updatePositionNeg( a, b, c, d );
 211     }
 212     lastx = x;
 213     lasty = y;
 214 }
 215
 216 void mouse(int button, int state, int x, int y)
 217 {
 218     if ( state == 0 )
 219     {
 220         switch ( button )
 221         {
 222         case GLUT_LEFT_BUTTON:  break;
 223         case GLUT_MIDDLE_BUTTON:tball.setAutoPosition(true);
 224                                 break;
 225         case GLUT_RIGHT_BUTTON:     tball.setAutoPositionNeg(true);
 226                                 break;
 227         }
 228         mouseb |= 1 << button;
 229     }
 230     else if ( state == 1 )
 231     {
 232         switch ( button )
 233         {
 234         case GLUT_LEFT_BUTTON:  break;
 235         case GLUT_MIDDLE_BUTTON:tball.setAutoPosition(false);
 236                                 break;
 237         case GLUT_RIGHT_BUTTON:     tball.setAutoPositionNeg(false);
 238                                 break;
 239         }
 240         mouseb &= ~(1 << button);
 241     }
 242     lastx = x;
 243     lasty = y;
 244 }
 245
 246 void vis(int visible)
 247 {
 248     if (visible == GLUT_VISIBLE)
 249     {
 250         glutIdleFunc(animate);
 251     }
 252     else
 253     {
 254         glutIdleFunc(NULL);
 255     }
 256 }
 257
 258 void key(unsigned char key, int x, int y)
 259 {
 260     switch ( key )
 261     {
 262         case 27:
 263             root        = NULL;
 264 //            file        = NULL;
 265             cam         = NULL;
 266             vp          = NULL;
 267             win         = NULL;
 268             cam_trans   = NULL;
 269             scene_trans = NULL;
 270             pPoly       = NULL;
 271             pCOver      = NULL;
 272             gwin        = NULL;
 273
 274             tx1o        = NULL;
 275             tx1e        = NULL;
 276
 277             vpFBO       = NULL;
 278             vpFBO_RB    = NULL;
 279             pTexBuffer  = NULL;
 280             pRenBuffer  = NULL;
 281             pImg        = NULL;
 282
 283             rentravact  = NULL;
 284
 285             OSG::osgExit();
 286
 287             exit(0);
 288         case 'f':
 289             vpFBO->setTravMask(~vpFBO->getTravMask());
 290             break;
 291         case 'd':
 292             oldTravMask = vpFBO->getTravMask();
 293
 294             if(oldTravMask == 0x0000)
 295             {
 296                 vpFBO->setTravMask(~vpFBO->getTravMask());
 297             }
 298
 299             dumpImg = true;
 300
 301             pTexBuffer                   ->setReadBack               (true);
 302             vpFBO->getFrameBufferObject()->setPostProcessOnDeactivate(true);
 303
 304             break;
 305
 306         case 'r':
 307         {
 308 //            OSG::FieldContainerFactory::the()->dump();
 309             //RenderBuffer Readback
 310             // Background
 311             OSG::SolidBackgroundUnrecPtr bkgndFBO_RB =
 312                 OSG::SolidBackground::create();
 313
 314             bkgndFBO_RB->setColor(OSG::Color3f(0.5,1.0,0.5));
 315
 316             // Viewport
 317
 318             vpFBO_RB = OSG::FBOViewport::create();
 319
 320             vpFBO_RB->setCamera    (cam        );
 321             vpFBO_RB->setBackground(bkgndFBO_RB);
 322             vpFBO_RB->setRoot      (root       );
 323             vpFBO_RB->setSize      (0, 0, 1, 1 );
 324
 325             OSG::FrameBufferObjectUnrecPtr pFBO_RB =
 326                 OSG::FrameBufferObject::create();
 327
 328             pRenBuffer = OSG::RenderBuffer::create();
 329
 330             OSG::RenderBufferUnrecPtr  pDepthBuffer_RB =
 331                 OSG::RenderBuffer::create();
 332
 333             pDepthBuffer_RB->setInternalFormat(GL_DEPTH_COMPONENT24   );
 334             pRenBuffer->setInternalFormat(GL_RGBA);
 335
 336             OSG::ImageUnrecPtr pImg_RB = OSG::Image::create();
 337
 338             OSG::UInt32 uiImgSize = 4096;
 339
 340             pImg_RB->set(OSG::Image::OSG_RGB_PF, uiImgSize, uiImgSize);
 341
 342             fprintf(stderr, "Image data : %p\n", pImg_RB->getData());
 343
 344             pRenBuffer->setImage(pImg_RB);
 345
 346             pFBO_RB->setSize(uiImgSize, uiImgSize);
 347
 348             pFBO_RB->setColorAttachment(pRenBuffer,     0);
 349             pFBO_RB->setDepthAttachment(pDepthBuffer_RB  );
 350
 351             pFBO_RB->editMFDrawBuffers()->clear();
 352             pFBO_RB->editMFDrawBuffers()->push_back(GL_COLOR_ATTACHMENT0_EXT);
 353
 354             vpFBO_RB->setFrameBufferObject(pFBO_RB);
 355
 356             pRenBuffer                      ->setReadBack               (true);
 357             vpFBO_RB->getFrameBufferObject()->setPostProcessOnDeactivate(true);
 358
 359             win->addPort(vpFBO_RB);
 360
 361             dumpImg_RB = true;
 362         }
 363         break;
 364
 365         case 'v':
 366             rentravact->setVolumeDrawing(!rentravact->getVolumeDrawing());
 367             break;
 368         case 'a':
 369             glDisable( GL_LIGHTING );
 370             std::cerr << "Lighting disabled." << std::endl;
 371             break;
 372         case 's':
 373             glEnable( GL_LIGHTING );
 374             std::cerr << "Lighting enabled." << std::endl;
 375             break;
 376         case 'z':
 377             pPoly->setFrontMode(GL_POINT);
 378             pPoly->setBackMode(GL_POINT);
 379             std::cerr << "PolygonMode: Point." << std::endl;
 380             break;
 381         case 'x':
 382             pPoly->setFrontMode(GL_LINE);
 383             pPoly->setBackMode(GL_LINE);
 384             std::cerr << "PolygonMode: Line." << std::endl;
 385             break;
 386         case 'c':
 387             pPoly->setFrontMode(GL_FILL);
 388             pPoly->setBackMode(GL_FILL);
 389             std::cerr << "PolygonMode: Fill." << std::endl;
 390             break;
 391         case 'p':
 392         {
 393             if(bPolyActive == true)
 394             {
 395                 OSG_ASSERT(pCOver->subChunk(pPoly) == true);
 396                 bPolyActive = false;
 397             }
 398             else
 399             {
 400                 OSG_ASSERT(pCOver->addChunk(pPoly) == true);
 401                 bPolyActive = true;
 402             }
 403             break;
 404         }
 405
 406         case ' ':
 407         {
 408             OSG::Matrix     m;
 409             OSG::Quaternion q;
 410             OSG::Vec3f      v;
 411
 412             q = oldq;
 413             v = oldv;
 414
 415             oldq = tball.getRotation();
 416             oldv = tball.getPosition();
 417
 418             move_obj = ! move_obj;
 419             if ( move_obj )
 420             {
 421                 puts("moving object");
 422 //                m = scene_trans->getSFMatrix()->getValue();
 423                 tball.setMode( OSG::Trackball::OSGCamera );
 424
 425             }
 426             else
 427             {
 428                 puts("moving camera");
 429 //                m = cam_trans->getSFMatrix()->getValue();
 430                 tball.setMode( OSG::Trackball::OSGObject );
 431             }
 432
 433 //            q.setValue(m);
 434             tball.setStartPosition( v, true );
 435             tball.setStartRotation( q, true );
 436
 437 //            std::cout << q << std::endl;
 438 //            std::cout << v << std::endl;
 439
 440 //            std::cout << " " << m[3][0] << " " << m[3][1] << " " << m[3][2] << std::endl;
 441
 442         }
 443         break;
 444     }
 445 }
 446
 447
 448 int init(int argc, char **argv)
 449 {
 450     OSG::osgInit(argc,argv);
 451
 452     // GLUT init
 453
 454     glutInit(&argc, argv);
 455     glutInitDisplayMode( GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE);
 456     int winid = glutCreateWindow("OpenSG");
 457     glutKeyboardFunc(key);
 458     glutVisibilityFunc(vis);
 459     glutReshapeFunc(reshape);
 460     glutDisplayFunc(display);
 461     glutMouseFunc(mouse);
 462     glutMotionFunc(motion);
 463
 464     glutIdleFunc(display);
 465
 466     // glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
 467
 468 //    glEnable( GL_DEPTH_TEST );
 469 //    glEnable( GL_LIGHTING );
 470 //    glEnable( GL_LIGHT0 );
 471 //    glFrontFace(GL_CW);
 472     glEnable(GL_CULL_FACE);
 473
 474     // OSG
 475
 476     OSG::SceneFileHandler::the()->print();
 477
 478     // create the graph
 479
 480     // beacon for camera and light
 481     OSG::NodeUnrecPtr b1n = OSG::Node::create();
 482     OSG::GroupUnrecPtr b1 = OSG::Group::create();
 483
 484     b1n->setCore( b1 );
 485
 486     // transformation
 487     OSG::NodeUnrecPtr t1n = OSG::Node::create();
 488     OSG::TransformUnrecPtr t1 = OSG::Transform::create();
 489
 490     t1n->setCore( t1 );
 491     t1n->addChild( b1n );
 492
 493     cam_trans = t1;
 494
 495     // light
 496
 497     OSG::NodeUnrecPtr dlight = OSG::Node::create();
 498     OSG::DirectionalLightUnrecPtr dl = OSG::DirectionalLight::create();
 499
 500     dlight->setCore( dl );
 501 //    dlight->setCore( Group::create() );
 502
 503     dl->setAmbient( .0, .0, .0, 1 );
 504     dl->setDiffuse( .8f, .8f, .8f, 1.f );
 505     dl->setDirection(0,0,1);
 506     dl->setBeacon( b1n);
 507
 508     // root
 509     root = OSG::Node::create();
 510     OSG::GroupUnrecPtr gr1 = OSG::Group::create();
 511
 512     root->setCore( gr1 );
 513     root->addChild( t1n );
 514     root->addChild( dlight );
 515
 516     // Load the file
 517
 518     OSG::NodeUnrecPtr file = NULL;
 519
 520     if(argc > 1)
 521         file = OSG::SceneFileHandler::the()->read(argv[1], NULL);
 522
 523     if ( file == NULL )
 524     {
 525         std::cerr << "Couldn't load file, ignoring" << std::endl;
 526
 527         file = OSG::makeSphere(4, 2.0);
 528
 529     }
 530
 531 #if 0
 532     OSG::GeometryPtr pGeo = cast_dynamic<OSG::GeometryPtr>(file->getCore());
 533
 534     if(pGeo == NULL && file->getNChildren() != 0)
 535     {
 536         pGeo = cast_dynamic<OSG::GeometryPtr>(file->getChild(0)->getCore());
 537     }
 538
 539     if(pGeo == NULL)
 540     {
 541         fprintf(stderr, "no geo\n");
 542     }
 543 #endif
 544
 545 //    OSG::GraphOpRefPtr op = OSG::GraphOpFactory::the()->create("Stripe");
 546
 547 //    op->traverse(file);
 548 //    createOptimizedPrimitives(pGeo);
 549 //    createSharedIndex(pGeo);
 550
 551     OSG::Thread::getCurrentChangeList()->commitChanges();
 552
 553 //    file->dump();
 554     file->updateVolume();
 555
 556 #if 0
 557     const char *outFileName = "/tmp/foo1.osg";
 558
 559     OSG::IndentFileOutStream outFileStream(outFileName);
 560
 561     if( !outFileStream )
 562     {
 563         std::cerr << "Can not open output stream to file: "
 564                   << outFileName << std::endl;
 565         return -1;
 566     }
 567
 568     std::cerr << "STARTING PRINTOUT:" << std::endl;
 569     OSGWriter writer( outFileStream, 4 );
 570
 571     writer.write( file );
 572
 573     outFileStream.close();
 574
 575     OSG::SceneFileHandler::the()->write(file, "/tmp/foo.osb");
 576 #endif
 577
 578
 579 //    return 0;
 580
 581
 582     OSG::Vec3f min,max;
 583     file->getVolume().getBounds( min, max );
 584
 585
 586     std::cout << "Volume: from " << min << " to " << max << std::endl;
 587
 588
 589     OSG::MultiCoreUnrecPtr pMCore = OSG::MultiCore::create();
 590
 591     pCOver      = OSG::ChunkOverrideGroup::create();
 592     scene_trans = OSG::Transform::create();
 593
 594     pMCore->addCore(scene_trans);
 595     pMCore->addCore(pCOver     );
 596
 597     OSG::NodeUnrecPtr sceneTrN = OSG::Node::create();
 598
 599     sceneTrN->setCore(pMCore);
 600     sceneTrN->addChild(file);
 601
 602
 603     dlight->addChild(sceneTrN);
 604
 605     std::cerr << "Tree: " << std::endl;
 606 //  root->dump();
 607
 608     // Camera
 609
 610     cam = OSG::PerspectiveCamera::create();
 611
 612     cam->setBeacon( b1n );
 613     cam->setFov( OSG::osgDegree2Rad( 90 ) );
 614     cam->setNear( 0.1f );
 615     cam->setFar( 100000 );
 616
 617     // Background
 618     OSG::SolidBackgroundUnrecPtr bkgnd = OSG::SolidBackground::create();
 619
 620     bkgnd->setColor(OSG::Color3f(1,0,0));
 621
 622     // Viewport
 623
 624     vp = OSG::Viewport::create();
 625
 626     vp->setCamera( cam );
 627     vp->setBackground( bkgnd );
 628     vp->setRoot( root );
 629     vp->setSize( 0,0, 1,1 );
 630
 631 #if 0
 632     OSG::UInt8 imgdata[] =
 633     {
 634         64,64,64, 128,128,128, 192,192,192, 255,255,255
 635     };
 636 #endif
 637
 638     pImg = OSG::Image::create();
 639
 640     pImg->set(OSG::Image::OSG_RGB_PF, 128, 128); //, 1, 1, 1, 0.0, imgdata);
 641
 642     tx1o = OSG::TextureObjChunk::create();
 643     tx1e = OSG::TextureEnvChunk::create();
 644
 645     tx1o->setImage    (pImg      );
 646     tx1o->setMinFilter(GL_LINEAR );
 647     tx1o->setMagFilter(GL_LINEAR );
 648     tx1o->setWrapS    (GL_CLAMP );
 649     tx1o->setWrapT    (GL_CLAMP );
 650     tx1e->setEnvMode  (GL_REPLACE);
 651
 652     OSG::SimpleMaterialUnrecPtr mat = OSG::SimpleMaterial::create();
 653
 654     mat->setDiffuse(OSG::Color3f(1,1,1));
 655     mat->setLit    (false              );
 656     mat->addChunk  (tx1o               );
 657     mat->addChunk  (tx1e               );
 658
 659     OSG::PolygonForegroundUnrecPtr pFG =  OSG::PolygonForeground::create();
 660
 661     pFG->setMaterial(mat);
 662
 663     OSG::MFPnt2f *pPos = pFG->editMFPositions();
 664     OSG::MFVec3f *pTex = pFG->editMFTexCoords();
 665
 666     pPos->push_back(OSG::Pnt2f(0.0f, 0.0f));
 667     pPos->push_back(OSG::Pnt2f(0.3f, 0.0f));
 668     pPos->push_back(OSG::Pnt2f(0.3f, 0.3f));
 669     pPos->push_back(OSG::Pnt2f(0.0f, 0.3f));
 670
 671     pTex->push_back(OSG::Vec3f(0.0f, 1.0f, 0.0f));
 672     pTex->push_back(OSG::Vec3f(1.0f, 1.0f, 0.0f));
 673     pTex->push_back(OSG::Vec3f(1.0f, 0.0f, 0.0f));
 674     pTex->push_back(OSG::Vec3f(0.0f, 0.0f, 0.0f));
 675
 676     vp->addForeground(pFG);
 677
 678
 679
 680     OSG::SimpleMaterialUnrecPtr matFgCheck = OSG::SimpleMaterial::create();
 681
 682     matFgCheck->setDiffuse(OSG::Color3f(0,1,0));
 683     matFgCheck->setLit    (false              );
 684
 685     OSG::PolygonForegroundUnrecPtr pFGCheck =  OSG::PolygonForeground::create();
 686
 687     pFGCheck->setMaterial(matFgCheck);
 688
 689     pPos = pFGCheck->editMFPositions();
 690
 691     pPos->push_back(OSG::Pnt2f(0.6f, 0.0f));
 692     pPos->push_back(OSG::Pnt2f(0.9f, 0.0f));
 693     pPos->push_back(OSG::Pnt2f(0.9f, 0.3f));
 694     pPos->push_back(OSG::Pnt2f(0.6f, 0.3f));
 695
 696
 697     vp->addForeground(pFG);
 698     vp->addForeground(pFGCheck);
 699 //    vp->dump();
 700
 701
 702     // Background
 703     OSG::SolidBackgroundUnrecPtr bkgndFBO = OSG::SolidBackground::create();
 704
 705     bkgndFBO->setColor(OSG::Color3f(1.0,0.5,0.5));
 706
 707     // Viewport
 708
 709     vpFBO = OSG::FBOViewport::create();
 710
 711     vpFBO->setCamera    (cam       );
 712     vpFBO->setBackground(bkgndFBO  );
 713     vpFBO->setRoot      (root      );
 714     vpFBO->setSize      (0, 0, 1, 1);
 715
 716     vpFBO->addForeground(pFGCheck);
 717
 718     OSG::FrameBufferObjectUnrecPtr pFBO = OSG::FrameBufferObject::create();
 719
 720                                pTexBuffer   = OSG::TextureBuffer::create();
 721     OSG::RenderBufferUnrecPtr  pDepthBuffer = OSG::RenderBuffer ::create();
 722
 723     pDepthBuffer->setInternalFormat(GL_DEPTH_COMPONENT24   );
 724
 725     pTexBuffer->setTexture(tx1o);
 726
 727     pFBO->setSize(128, 128);
 728
 729     pFBO->setColorAttachment(pTexBuffer, 0);
 730     pFBO->setDepthAttachment(pDepthBuffer );
 731
 732     pFBO->editMFDrawBuffers()->clear();
 733     pFBO->editMFDrawBuffers()->push_back(GL_COLOR_ATTACHMENT0_EXT);
 734
 735
 736     vpFBO->setFrameBufferObject(pFBO);
 737
 738
 739
 740     // Window
 741     std::cout << "GLUT winid: " << winid << std::endl;
 742
 743
 744     GLint glvp[4];
 745
 746     glGetIntegerv( GL_VIEWPORT, glvp );
 747
 748     gwin = OSG::GLUTWindow::create();
 749     gwin->setGlutId(winid);
 750     gwin->setSize( glvp[2], glvp[3] );
 751
 752     win = gwin;
 753
 754     win->addPort(vpFBO   );
 755     win->addPort(vp      );
 756
 757     win->init();
 758
 759     // Action
 760
 761     rentravact = OSG::RenderAction::create();
 762 //    renact->setFrustumCulling(false);
 763
 764
 765     // tball
 766
 767     OSG::Vec3f pos;
 768     pos.setValues(min[0] + ((max[0] - min[0]) * 0.5),
 769                   min[1] + ((max[1] - min[1]) * 0.5),
 770                   max[2] + ( max[2] - min[2] ) * 1.5 );
 771
 772     float scale = (max[2] - min[2] + max[1] - min[1] + max[0] - min[0]) / 6;
 773
 774     OSG::Pnt3f tCenter(min[0] + (max[0] - min[0]) / 2,
 775                        min[1] + (max[1] - min[1]) / 2,
 776                        min[2] + (max[2] - min[2]) / 2);
 777
 778     fprintf(stderr, "Startpos : %f %f %f\n", pos[0], pos[1], pos[2]);
 779
 780     tball.setMode( OSG::Trackball::OSGObject );
 781     tball.setStartPosition( pos, true );
 782     tball.setSum( true );
 783     tball.setTranslationMode( OSG::Trackball::OSGFree );
 784     tball.setTranslationScale(scale);
 785     tball.setRotationCenter(tCenter);
 786
 787     // run...
 788
 789     pPoly = OSG::PolygonChunk::create();
 790
 791     pCOver->subChunk(pPoly);
 792
 793     return 0;
 794 }
 795
 796 int main (int argc, char **argv)
 797 {
 798     init(argc, argv);
 799
 800     glutMainLoop();
 801
 802     return 0;
 803 }
 804