Examples/Simple/dyndrawing2.cpp

   1 // OpenSG example: dyndrawing2.cpp
   2 //
   3 // User interface:
   4 //  a) mouse    => standard navigator
   5 //  b) keyboard =>
   6 //      '1': toggle between static and dynamic mode
   7 //
   8
   9 #include <stdlib.h>
  10 #include <stdio.h>
  11 #include <string>
  12 #include <sstream>
  13 #include <fstream>
  14 #include <vector>
  15 #include <boost/tuple/tuple.hpp>
  16 #include <boost/scoped_ptr.hpp>
  17 #include <boost/random.hpp>
  18 #include <boost/random/lagged_fibonacci.hpp>
  19
  20 #ifdef OSG_BUILD_ACTIVE
  21 // Headers
  22 #include <OSGGLUT.h>
  23 #include <OSGConfig.h>
  24 #include <OSGSimpleGeometry.h>
  25 #include <OSGGLUTWindow.h>
  26 #include <OSGGradientBackground.h>
  27 #include <OSGSimpleSceneManager.h>
  28 #include <OSGSceneFileHandler.h>
  29 #include <OSGAction.h>
  30 #include <OSGFrameBufferObject.h>
  31 #include <OSGRenderBuffer.h>
  32 #include <OSGTextureBuffer.h>
  33 #include <OSGSimpleStage.h>
  34 #include <OSGPassiveViewport.h>
  35 #include <OSGVisitSubTree.h>
  36 #include <OSGImage.h>
  37 #include <OSGTextureObjChunk.h>
  38 #include <OSGFBOBackground.h>
  39 #include <OSGFBOGrabForeground.h>
  40
  41 #else
  42 // Headers
  43 #include <OpenSG/OSGGLUT.h>
  44 #include <OpenSG/OSGConfig.h>
  45 #include <OpenSG/OSGSimpleGeometry.h>
  46 #include <OpenSG/OSGGLUTWindow.h>
  47 #include <OpenSG/OSGGradientBackground.h>
  48 #include <OpenSG/OSGSimpleSceneManager.h>
  49 #include <OpenSG/OSGSceneFileHandler.h>
  50 #include <OpenSG/OSGAction.h>
  51 #include <OpenSG/OSGFrameBufferObject.h>
  52 #include <OpenSG/OSGRenderBuffer.h>
  53 #include <OpenSG/OSGTextureBuffer.h>
  54 #include <OpenSG/OSGSimpleStage.h>
  55 #include <OpenSG/OSGPassiveViewport.h>
  56 #include <OpenSG/OSGVisitSubTree.h>
  57 #include <OpenSG/OSGImage.h>
  58 #include <OpenSG/OSGTextureObjChunk.h>
  59 #include <OpenSG/OSGFBOBackground.h>
  60
  61 #endif
  62
  63 OSG_USING_NAMESPACE // just for convenience but not recommended
  64
  65 //#define USE_MULTISAMPLING
  66
  67 //
  68 // The number of tori to render
  69 // ============================
  70 //
  71 #ifdef _DEBUG
  72 const int max_tori =  500;
  73 #else
  74 const int max_tori = 10000;
  75 #endif
  76
  77 //
  78 // Helper class for building FBO used by SimpleFBO see below
  79 // =========================================================
  80 //
  81 class FBOBuilder
  82 {
  83 public:
  84     struct TextureData {
  85         TextureData()
  86             : enable(true)
  87             , pixel_format(Image::OSG_RGBA_PF)
  88             , type(Image::OSG_UINT8_IMAGEDATA)
  89             , main_memory(true)
  90             , texObj(NULL)
  91             , image(NULL) {}
  92        ~TextureData() {texObj = NULL; image = NULL; }
  93
  94         bool enable;
  95         UInt32 pixel_format;
  96         Int32 type;
  97         bool main_memory;
  98         TextureObjChunkUnrecPtr texObj;
  99         ImageUnrecPtr image;
 100     };
 101
 102     typedef std::vector<TextureData> VecTextureDataT;
 103
 104 public:
 105             FBOBuilder(const VecTextureDataT& buffers, bool depth,  bool stencil, const TextureData& ds_buffer)
 106                 : _buffers(buffers) , _depth(depth) , _stencil(stencil) , _ds_buffer(ds_buffer) {}
 107            ~FBOBuilder() {}
 108
 109 public:
 110     FrameBufferObjectTransitPtr    operator()(UInt32 width, UInt32 height) const;
 111
 112 private:
 113     VecTextureDataT _buffers;
 114     bool            _depth;
 115     bool            _stencil;
 116     TextureData     _ds_buffer;
 117 };
 118
 119 FrameBufferObjectTransitPtr FBOBuilder::operator()(
 120     UInt32 width,
 121     UInt32 height) const
 122 {
 123     //
 124     // Setup the FBO
 125     //
 126     FrameBufferObjectUnrecPtr fbo = FrameBufferObject::create();
 127     //
 128     // multiple color buffers
 129     //
 130     for (UInt32 idx = 0; idx < _buffers.size(); ++idx) {
 131         //
 132         // use textures?
 133         //
 134         if (_buffers[idx].enable) {
 135             ImageUnrecPtr           texImg = (_buffers[idx].image  == NULL ? Image::create()           : _buffers[idx].image);
 136             TextureObjChunkUnrecPtr texObj = (_buffers[idx].texObj == NULL ? TextureObjChunk::create() : _buffers[idx].texObj);
 137             TextureBufferUnrecPtr   texBuf = TextureBuffer::create();
 138
 139             if (_buffers[idx].image == NULL)
 140                 texImg->set(_buffers[idx].pixel_format,
 141                             width, height, 1, 1, 1, 0.f, NULL,
 142                             _buffers[idx].type,
 143                             _buffers[idx].main_memory);
 144
 145             texObj->setImage(texImg);
 146             texBuf->setTexture(texObj);
 147
 148             fbo->setColorAttachment(texBuf, idx);
 149         } else
 150         //
 151         // no, then use simple render buffer
 152         //
 153         {
 154             RenderBufferUnrecPtr renBuf = RenderBuffer::create();
 155             renBuf->setInternalFormat(_buffers[idx].pixel_format);
 156             fbo->setColorAttachment(renBuf, idx);
 157         }
 158         fbo->editMFDrawBuffers()->push_back(GL_COLOR_ATTACHMENT0_EXT + idx);
 159     }
 160     //
 161     // a sole depth buffer
 162     //
 163     if (_depth && !_stencil) {
 164         //
 165         // use textures?
 166         //
 167         if (_ds_buffer.enable) {
 168             ImageUnrecPtr           texImg = (_ds_buffer.image  == NULL ? Image::create()           : _ds_buffer.image);
 169             TextureObjChunkUnrecPtr texObj = (_ds_buffer.texObj == NULL ? TextureObjChunk::create() : _ds_buffer.texObj);
 170             TextureBufferUnrecPtr   texBuf = TextureBuffer::create();
 171
 172             if (_ds_buffer.image == NULL)
 173                 texImg->set(_ds_buffer.pixel_format,
 174                             width, height, 1, 1, 1, 0.f, NULL,
 175                             _ds_buffer.type,
 176                             _ds_buffer.main_memory);
 177
 178             texObj->setImage(texImg);
 179
 180             if (_ds_buffer.texObj == NULL) {
 181                 texObj->setInternalFormat(GL_DEPTH_COMPONENT24);
 182                 texObj->setExternalFormat(GL_DEPTH_COMPONENT24);
 183             }
 184             texBuf->setTexture(texObj);
 185
 186             fbo->setDepthAttachment(texBuf);
 187         } else
 188         //
 189         // no, then use simple render buffer
 190         //
 191         {
 192             RenderBufferUnrecPtr renBuf = RenderBuffer::create();
 193             renBuf->setInternalFormat(GL_DEPTH_COMPONENT24);
 194             fbo->setDepthAttachment(renBuf);
 195         }
 196     } else
 197     //
 198     // or a combined depth/stencil buffer
 199     //
 200     if (_depth && _stencil) {
 201         //
 202         // use textures?
 203         //
 204         if (_ds_buffer.enable) {
 205             ImageUnrecPtr           texImg = (_ds_buffer.image  == NULL ? Image::create()           : _ds_buffer.image);
 206             TextureObjChunkUnrecPtr texObj = (_ds_buffer.texObj == NULL ? TextureObjChunk::create() : _ds_buffer.texObj);
 207             TextureBufferUnrecPtr   texBuf = TextureBuffer::create();
 208
 209             if (_ds_buffer.image == NULL)
 210                 texImg->set(GL_DEPTH_STENCIL_EXT,
 211                             width, height, 1, 1, 1, 0.f, NULL,
 212                             GL_UNSIGNED_INT_24_8,
 213                             _ds_buffer.main_memory);
 214
 215             texObj->setImage(texImg);
 216             texObj->setInternalFormat(GL_DEPTH24_STENCIL8_EXT);
 217             texObj->setExternalFormat(GL_DEPTH_STENCIL_EXT);
 218             texBuf->setTexture(texObj);
 219
 220             fbo->setDepthAttachment(texBuf);
 221             fbo->setStencilAttachment(texBuf);
 222         } else
 223         //
 224         // no, then use simple render buffer
 225         //
 226         {
 227             RenderBufferUnrecPtr renBuf = RenderBuffer::create();
 228             renBuf->setInternalFormat(GL_DEPTH24_STENCIL8);
 229             fbo->setDepthAttachment(renBuf);
 230             fbo->setStencilAttachment(renBuf);
 231         }
 232     }
 233
 234     fbo->setWidth (width );
 235     fbo->setHeight(height);
 236
 237     return FrameBufferObjectTransitPtr(fbo);
 238 }
 239
 240 //
 241 // Convenience helper object wrapping the FBO uses FBOBuilder internally
 242 // =====================================================================
 243 //
 244 class SimpleFBO
 245 {
 246 public:
 247                 SimpleFBO(UInt32 width,
 248                           UInt32 height,
 249                           bool color_textured,
 250                           bool depth_stencil_textured,
 251                           bool read_back_color = true,
 252                           bool read_back_depth_stencil = false);
 253
 254                 SimpleFBO(UInt32 width,
 255                           UInt32 height,
 256                           const std::vector<FBOBuilder::TextureData>& buffers,
 257                           bool depth,
 258                           bool stencil,
 259                           const FBOBuilder::TextureData& ds_buffer);
 260
 261                ~SimpleFBO() { _fbo = NULL; }
 262
 263 public:
 264     FrameBufferObject*     fbo             () const { return _fbo; }
 265
 266     FrameBufferAttachment* colorBuffer     (UInt32 idx = 0) const { return _fbo ? _fbo->getColorAttachments(idx) : NULL; }
 267     FrameBufferAttachment* depthBuffer     () const               { return _fbo ? _fbo->getDepthAttachment()     : NULL; }
 268     FrameBufferAttachment* stencilBuffer   () const               { return _fbo ? _fbo->getStencilAttachment()   : NULL;}
 269
 270     TextureObjChunk*       colorTexObj     (UInt32 idx = 0) const;
 271     TextureObjChunk*       depthTexObj     () const;
 272     TextureObjChunk*       stencilTexObj   () const;
 273
 274 private:
 275     FrameBufferObjectRecPtr     _fbo;
 276 };
 277
 278 SimpleFBO::SimpleFBO(
 279     UInt32 width,
 280     UInt32 height,
 281     bool color_textured,
 282     bool depth_stencil_textured,
 283     bool read_back_color,
 284     bool read_back_depth_stencil)
 285 : _fbo(NULL)
 286 {
 287     FBOBuilder::TextureData color_data;
 288     color_data.enable = color_textured;
 289     color_data.main_memory = read_back_color;
 290
 291     FBOBuilder::TextureData depth_stencil_data;
 292     depth_stencil_data.enable = depth_stencil_textured;
 293     depth_stencil_data.main_memory = read_back_depth_stencil;
 294
 295     FBOBuilder::VecTextureDataT color_vec;
 296     color_vec.push_back(color_data);
 297
 298     FBOBuilder fbo_builder(color_vec, true, true, depth_stencil_data);
 299
 300     _fbo = fbo_builder(width, height);
 301 }
 302
 303 SimpleFBO::SimpleFBO(
 304     UInt32 width,
 305     UInt32 height,
 306     const std::vector<FBOBuilder::TextureData>& buffers,
 307     bool depth,
 308     bool stencil,
 309     const FBOBuilder::TextureData& ds_buffer)
 310 : _fbo(NULL)
 311 {
 312     FBOBuilder fbo_builder(buffers, depth, stencil, ds_buffer);
 313
 314     _fbo = fbo_builder(width, height);
 315 }
 316
 317 TextureObjChunk* SimpleFBO::colorTexObj(UInt32 idx) const
 318 {
 319     TextureBuffer* texBuf = dynamic_cast<TextureBuffer*>(colorBuffer(idx));
 320     if (texBuf)
 321         return texBuf->getTexture();
 322
 323     return NULL;
 324 }
 325
 326 TextureObjChunk* SimpleFBO::depthTexObj() const
 327 {
 328     TextureBuffer* texBuf = dynamic_cast<TextureBuffer*>(depthBuffer());
 329     if (texBuf)
 330         return texBuf->getTexture();
 331
 332     return NULL;
 333 }
 334
 335 TextureObjChunk* SimpleFBO::stencilTexObj() const
 336 {
 337     TextureBuffer* texBuf = dynamic_cast<TextureBuffer*>(stencilBuffer());
 338     if (texBuf)
 339         return texBuf->getTexture();
 340
 341     return NULL;
 342 }
 343
 344 //
 345 // function forward declarations
 346 // =============================
 347 //
 348 static void cleanup(void);
 349 static void display(void);
 350 static void reshape(int w, int h);
 351 static void mouse(int button, int state, int x, int y);
 352 static void motion(int x, int y);
 353 static void keyboard(unsigned char k, int, int);
 354 static int  setupGLUT(int *argc, char *argv[]);
 355 static int  doMain(int argc, char *argv[]);
 356
 357
 358 static NodeTransitPtr   createStaticScene();
 359 static NodeTransitPtr   createDynamicScene();
 360
 361 static void             applyRenderMode();
 362 static void             enableStaticRendering();
 363 static void             enableDynamicRendering();
 364
 365 #if 0
 366 static Node*            rootNode(Node* node);
 367 #endif
 368
 369 //
 370 // global state of example
 371 // =======================
 372 //
 373 bool                     static_render_mode;
 374 SimpleSceneManagerRefPtr mgr;
 375 NodeRefPtr               staticScene;
 376 NodeRefPtr               dynamicScene;
 377 GLUTWindowRefPtr         win;
 378 ViewportRefPtr           viewport;
 379 GradientBackgroundRefPtr background;
 380
 381 boost::scoped_ptr<SimpleFBO> spSimpleFBO;
 382
 383 //
 384 // functions implementation
 385 // ========================
 386 //
 387
 388 static void cleanup(void)
 389 {
 390     mgr   = NULL;
 391     staticScene = NULL;
 392     dynamicScene = NULL;
 393     win   = NULL;
 394     viewport = NULL;
 395     background = NULL;
 396     spSimpleFBO.reset();
 397 }
 398
 399 static void display(void)
 400 {
 401     commitChanges();
 402     mgr->redraw();
 403 }
 404
 405 static void reshape(int w, int h)
 406 {
 407     mgr->resize(w,h);
 408     glutPostRedisplay();
 409 }
 410
 411 static void mouse(int button, int state, int x, int y)
 412 {
 413     if (state)
 414         mgr->mouseButtonRelease(button, x, y);
 415     else
 416         mgr->mouseButtonPress(button, x, y);
 417
 418     glutPostRedisplay();
 419 }
 420
 421 static void motion(int x, int y)
 422 {
 423     mgr->mouseMove(x, y);
 424     glutPostRedisplay();
 425 }
 426
 427 static void keyboard(unsigned char k, int, int)
 428 {
 429     switch(k)
 430     {
 431     case 27:
 432     case 'q':
 433     case 'Q':
 434     {
 435         cleanup();
 436         osgExit();
 437
 438         std::exit(EXIT_SUCCESS);
 439     }
 440     break;
 441
 442     case '1':
 443     {
 444         static_render_mode = !static_render_mode;
 445         applyRenderMode();
 446     }
 447     break;
 448     }
 449     glutPostRedisplay();
 450 }
 451
 452 //
 453 // initialize GLUT
 454 //
 455 static int setupGLUT(int *argc, char *argv[])
 456 {
 457     glutInit(argc, argv);
 458
 459     glutInitDisplayMode(
 460         GLUT_RGB | GLUT_DEPTH | GLUT_STENCIL | GLUT_DOUBLE
 461 #ifdef USE_MULTISAMPLING
 462       | GLUT_MULTISAMPLE
 463 #endif
 464     );
 465
 466     int winid = glutCreateWindow("OpenSG");
 467
 468     glutReshapeFunc(reshape);
 469     glutDisplayFunc(display);
 470     glutIdleFunc(display);
 471     glutMouseFunc(mouse);
 472     glutMotionFunc(motion);
 473     glutKeyboardFunc(keyboard);
 474
 475     return winid;
 476 }
 477
 478 //
 479 // setup scene
 480 //
 481 static int doMain(int argc, char *argv[])
 482 {
 483     preloadSharedObject("OSGFileIO");
 484     preloadSharedObject("OSGImageFileIO");
 485
 486     osgInit(argc,argv);
 487
 488     int winid = setupGLUT(&argc, argv);
 489
 490     win = GLUTWindow::create();
 491     win->setGlutId(winid);
 492     win->init();
 493
 494     if(argc < 2)
 495     {
 496         FWARNING(("No file given!\n"));
 497         FWARNING(("Supported file formats:\n"));
 498
 499         std::list<const char*> suffixes;
 500         SceneFileHandler::the()->getSuffixList(suffixes);
 501
 502         for(std::list<const char*>::iterator it  = suffixes.begin();
 503                                             it != suffixes.end();
 504                                         ++it)
 505         {
 506             FWARNING(("%s\n", *it));
 507         }
 508
 509         staticScene = createStaticScene();
 510     }
 511     else
 512     {
 513         staticScene = SceneFileHandler::the()->read(argv[1]);
 514     }
 515
 516     dynamicScene = createDynamicScene();
 517
 518     spSimpleFBO.reset(new SimpleFBO(2, 2, true, true, true, false));
 519
 520     commitChanges();
 521
 522     NodeUnrecPtr root = makeCoredNode<Group>();
 523
 524     mgr = SimpleSceneManager::create();
 525     mgr->setWindow(win);
 526     mgr->setRoot  (root);
 527
 528     background = GradientBackground::create();
 529     background->addLine(Color3f(0,0,0), 0);
 530     background->addLine(Color3f(1,1,1), 1);
 531
 532     viewport = win->getPort(0);
 533     viewport->setBackground(background);
 534
 535     static_render_mode = true;
 536     applyRenderMode();
 537
 538     mgr->showAll();
 539
 540     return 0;
 541 }
 542
 543 //
 544 // create an arbitrarly complex render scene
 545 //
 546 static NodeTransitPtr createStaticScene()
 547 {
 548     NodeUnrecPtr root = makeCoredNode<Group>();
 549
 550     typedef boost::mt19937 base_generator_type;
 551     static base_generator_type generator(0);
 552     static boost::uniform_01<float> value;
 553     static boost::variate_generator< base_generator_type, boost::uniform_01<float> > die(generator, value);
 554
 555     for (int i = 0; i < max_tori; ++i) {
 556         NodeUnrecPtr scene = makeTorus(.5, 2, 32, 32);
 557
 558         TransformUnrecPtr transformCore = Transform::create();
 559         Matrix mat;
 560
 561         mat.setIdentity();
 562
 563         float x = 500.f * die();
 564         float y = 500.f * die();
 565         float z = 500.f * die();
 566
 567         float e1 = die();
 568         float e2 = die();
 569         float e3 = die();
 570
 571         Vec3f v(e1,e2,e3);
 572         v.normalize();
 573
 574         float a = TwoPi * die();
 575
 576         Quaternion q(v, a);
 577
 578         mat.setTranslate(x,y,z);
 579         mat.setRotate(q);
 580
 581         transformCore->setMatrix(mat);
 582
 583         NodeUnrecPtr trafo = makeNodeFor(transformCore);
 584
 585         trafo->addChild(scene);
 586
 587         root->addChild(trafo);
 588     }
 589
 590     return NodeTransitPtr(root);
 591 }
 592
 593 static NodeTransitPtr createDynamicScene()
 594 {
 595     NodeUnrecPtr scene = makeCylinder(30, 100, 16, true, true, true);
 596     return NodeTransitPtr(scene);
 597 }
 598
 599 static void applyRenderMode()
 600 {
 601     if (static_render_mode)
 602     {
 603         enableStaticRendering();
 604     }
 605     else
 606     {
 607         enableDynamicRendering();
 608     }
 609 }
 610
 611 static void enableStaticRendering()
 612 {
 613 //    UInt32 width  = win->getWidth();
 614 //    UInt32 height = win->getHeight();
 615
 616     FBOGrabForegroundUnrecPtr fboGrabForeground = FBOGrabForeground::create();
 617     fboGrabForeground->setFrameBufferObject(spSimpleFBO->fbo());
 618     fboGrabForeground->setAutoResize(true);
 619
 620     viewport->addForeground(fboGrabForeground);
 621     viewport->setBackground(background);
 622
 623     NodeUnrecPtr root = makeCoredNode<Group>();
 624     root->addChild(staticScene);
 625     mgr->setRoot(root);
 626 }
 627
 628 static void enableDynamicRendering()
 629 {
 630     FBOBackgroundUnrecPtr fboBckgnd = FBOBackground::create();
 631     fboBckgnd->setFrameBufferObject(spSimpleFBO->fbo());
 632
 633     viewport->clearForegrounds();
 634     viewport->setBackground(fboBckgnd);
 635
 636     NodeUnrecPtr root = makeCoredNode<Group>();
 637     root->addChild(dynamicScene);
 638     mgr->setRoot(root);
 639 }
 640
 641 #if 0
 642 static Node* rootNode(Node* node)
 643 {
 644     Node* root = NULL;
 645     while (node) {
 646         root = node;
 647         node = node->getParent();
 648     }
 649     return root;
 650 }
 651 #endif
 652
 653 //
 654 // main entry point
 655 //
 656 int main(int argc, char *argv[])
 657 {
 658     int ret = doMain(argc, argv);
 659
 660     glutMainLoop();
 661
 662     cleanup();
 663
 664     osgExit();
 665
 666     return ret;
 667 }
 668