Ticket #112: testSwitch.cpp

#include <OSGGLUT.h>
#include <OSGConfig.h>
#include <OSGSimpleGeometry.h>
#include <OSGPassiveWindow.h>
#include <OSGSimpleSceneManager.h>
#include <OSGSceneFileHandler.h>

#include <OSGDrawable.h>
#include <OSGSwitch.h>

OSG_USING_NAMESPACE

SimpleSceneManager    *mgr(NULL);
RenderTraversalAction *tact = NULL;

PassiveWindowPtr pwin;
NodePtr          swNode;
SwitchPtr        swCore;

bool show = true;
bool bGLFinish = false;

// redraw the window
void display(void)
{
    mgr->redraw();

    // all done, swap
    glutSwapBuffers();
}

// 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:
        {
            osgExit();
            exit(0);
        }

        // Output help about the controls
        // - If you add an option, please add it here too.
        case '?':
        case '/':
        case 'h':
        {
            std::cerr << "\nControls:"
                      << "v: Toggle drawing of volumes.\n"
                      << "a: Show all.\n"
                      << "s: Toggle switch node.\n"
                      << "g: toggle using gl finish.\n"
                      << std::endl;
        }
        break;

        case 'v':
        {
            mgr->getAction()->setVolumeDrawing(
                                    !mgr->getAction()->getVolumeDrawing());
            std::cerr << "Volume Drawing: "
                      << (mgr->getAction()->getVolumeDrawing()?"on":"off")
                      << std::endl;
        }
        break;

        case 'a':
        {
            mgr->showAll();
            
            std::cerr << "Show all." << std::endl;
        }
        break;
        
        case 's':
        {
            Int32  choice  = swCore->getChoice();
            UInt32 choices = swNode->getNChildren();
            
            if(choice == Switch::ALL)
            {
                choice = Switch::NONE;
                std::cerr << "Switch: NONE" << std::endl;
            }
            else if(choice == Switch::NONE)
            {
                choice = (choices > 0) ? 0 : Switch::ALL;
                std::cerr << "Switch: " << choice << std::endl;
            }
            else
            {
                choice += 1;
                
                if(choice == choices)
                {
                    choice = Switch::ALL;
                    std::cerr << "Switch: ALL" << std::endl;
                }
                else
                {
                    std::cerr << "Switch: " << choice << std::endl;
                }
            }
            
            swCore->setChoice(choice);
        }
        break;
        
        case 'g':
            bGLFinish = !bGLFinish;
            tact->setUseGLFinish(bGLFinish);
            std::cerr << "Set use gl finish to: " << bGLFinish << std::endl;
            break;
    }
    
    commitChanges();
}

NodePtr buildScene(void)
{
    swNode = Node::create();
    swCore = Switch::create();
    swCore->setChoice(Switch::ALL);
    swNode->setCore(swCore);
    
    NodePtr      t1Node = Node::create();
    TransformPtr t1Core = Transform::create();
    t1Core->editMatrix().setTranslate( 10.0, 0.0, 0.0);
    t1Node->setCore(t1Core);
    
    NodePtr      t2Node = Node::create();
    TransformPtr t2Core = Transform::create();
    t2Core->editMatrix().setTranslate(-10.0, 0.0, 0.0);
    t2Node->setCore(t2Core);
    
    NodePtr g1Node = makeTorus( 6.0, 10.0, 32, 16);
    NodePtr g2Node = makeCone (10.0,  4.0, 32, true, true);
    
    t1Node->addChild(g1Node);
    t2Node->addChild(g2Node);
    
    swNode->addChild(t1Node);
    swNode->addChild(t2Node);
    
    return swNode;
}


int main(int argc, char **argv)
{
    osgInit(argc,argv);

    // GLUT init
    glutInit(&argc, argv);

    glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);

    glutInitWindowSize(500, 500);
    glutCreateWindow("OpenSG");

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

    pwin=PassiveWindow::create();
    pwin->init();

    // create the scene
    NodePtr scene;

    scene = buildScene();

    // create the SimpleSceneManager helper
    mgr = new SimpleSceneManager;

    // create the window and initial camera/viewport
    mgr->setWindow(pwin );
    // tell the manager what to manage
    mgr->setRoot  (scene);

    Thread::getCurrentChangeList()->commitChanges();

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

    mgr->setUseTraversalAction(true);

    tact = RenderTraversalAction::create();

    mgr->setAction(tact);

    // GLUT main loop
    glutMainLoop();

    return 0;
}