Ticket #168: crappy_little_bug.cpp

// Headers
#include <OpenSG/OSGGLUT.h>
#include <OpenSG/OSGConfig.h>
#include <OpenSG/OSGSimpleGeometry.h>
#include <OpenSG/OSGGLUTWindow.h>
#include <OpenSG/OSGSimpleSceneManager.h>
#include <OpenSG/OSGAction.h>
#include <vector>

// the general scene file loading handler
#include <OpenSG/OSGSceneFileHandler.h>
#include <boost/bind.hpp>

// Activate the OpenSG namespace
OSG_USING_NAMESPACE

// The SimpleSceneManager to manage simple applications
SimpleSceneManager *mgr;
GroupNodePtr       gScene;

std::map<unsigned, GroupNodePtr>  gTransformRoots;


// forward declaration so we can have the interesting stuff upfront
int setupGLUT( int *argc, char *argv[] );
void updateScene(void);


// Initialize GLUT & OpenSG and set up the scene
int main(int argc, char **argv)
{
    // OSG init
    osgInit(argc,argv);

    // GLUT init
    int winid = setupGLUT(&argc, argv);

    // the connection between GLUT and OpenSG
    GLUTWindowPtr gwin= GLUTWindow::create();
    gwin->setId(winid);
    gwin->init();

    // load the scene
    gScene = GroupNodePtr::create();

    commitChanges();

    for (unsigned i=0;i<20000;i++)
    {
       updateScene();
       commitChanges();
    }

    // create the SimpleSceneManager helper
    mgr = new SimpleSceneManager;

    // tell the manager what to manage
    mgr->setWindow(gwin );
    mgr->setRoot  (gScene.node());

    // show the whole scene
    mgr->showAll();

    // GLUT main loop
    glutMainLoop();

    return 0;
}

//
// GLUT callback functions
//

GroupNodePtr buildGeomChain()
{
   GroupNodePtr         root = GroupNodePtr::create();
   TransformNodePtr    xform = TransformNodePtr::create();
   GeometryPtr          geom = makeBoxGeo(1000000, 1000000, 1000000, 10, 10, 10);
   NodeRefPtr      geom_node = NodeRefPtr(Node::create());
   geom_node->setCore(geom);

   SimpleMaterialPtr     mat = SimpleMaterial::create();
   mat->setDiffuse(Color3f(1,1,1));
   geom->setMaterial(mat);

   root.node()->addChild(xform);
   xform.node()->addChild(geom_node);
   return root;
}

void updateScene(void)
{
   static int i=0;
   i++;

   std::cerr << "Iter: " << i << std::endl;

   // Simple case of remove a child and add a child
#if 1
   if(gScene.node()->getNChildren() > 0)
   {
      gScene.node()->subChild(0);
   }

   GroupNodePtr new_chain = buildGeomChain();
   gScene.node()->addChild(new_chain.node());

   // More complex case of dynamic adding and removing over time
#else
   unsigned add_per_frame = 5;
   unsigned max_num = 100;

   std::cerr << "Adding geom: " << std::endl;
   for (unsigned x=0;x<add_per_frame;x++)
   {
      GroupNodePtr new_chain = buildGeomChain();
      gScene.node()->addChild(new_chain.node());
      gTransformRoots[(i*add_per_frame)+x] = new_chain;
      std::cerr << "   added:" << (i*add_per_frame)+x << std::endl;
   }

   int num_extra = gScene.node()->getNChildren()-max_num;
   if (num_extra > 0)
   {
      // Pick the first num_extra items in the map and remove them
      std::cerr << "num extra: " << num_extra << std::endl;
      std::vector<unsigned> to_remove;
      for (std::map<unsigned, GroupNodePtr>::iterator j=gTransformRoots.begin();
            j!=gTransformRoots.end() && (to_remove.size() < num_extra); j++)
      { to_remove.push_back((*j).first); }

      std::cerr << "Removing: [" << to_remove.size() << "]" << std::endl;
      for(unsigned k=0; k<to_remove.size(); k++)
      {
         unsigned remove_idx       = to_remove[k];
         std::cerr << "    remove: " << remove_idx << std::endl;
         GroupNodePtr remove_group = gTransformRoots[remove_idx];
         gTransformRoots.erase(remove_idx);
         gScene.node()->subChild(remove_group.node());
      }
   }

   std::cerr << "    num nodes: " << gTransformRoots.size() << std::endl;
#endif

}

// redraw the window
void display(void)
{
   //updateScene();
   //commitChanges();

    mgr->idle();
    mgr->redraw();
}

// react to size changes
void reshape(int w, int h)
{
    mgr->resize(w, h);
    glutPostRedisplay();
}

// react to mouse button presses
void mouse(int button, int state, int x, int y)
{

    if (state)
        mgr->mouseButtonRelease(button, x, y);
    else
        mgr->mouseButtonPress(button, x, y);

    glutPostRedisplay();
}

// react to mouse motions with pressed buttons
void motion(int x, int y)
{

    mgr->mouseMove(x, y);
    glutPostRedisplay();
}

// react to keys
void keyboard(unsigned char k, int , int )
{
    switch(k)
    {
        case 27:
        {
            OSG::osgExit();
            exit(0);
        }
        break;

        case 'f':
        {
            mgr->setNavigationMode(Navigator::FLY);
        }
        break;

        case 't':
        {
            mgr->setNavigationMode(Navigator::TRACKBALL);
        }
        break;
    }
}

// setup the GLUT library which handles the windows for us
int setupGLUT(int *argc, char *argv[])
{
    glutInit(argc, argv);
    glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);

    int winid = glutCreateWindow("OpenSG");

    glutReshapeFunc(reshape);
    glutDisplayFunc(display);
    glutIdleFunc(display);
    glutMouseFunc(mouse);
    glutMotionFunc(motion);
    glutKeyboardFunc(keyboard);

    return winid;
}