Examples/Simple/switch.cpp

   1 // OpenSG Tutorial Example: Switch
   2 //
   3 // This example shows how to use the Switch NodeCore to selectively display one
   4 // of a number of children of a node.
   5 //
   6 // You can use the keys 1-0 to display a single node, 'a' to select all nodes
   7 // and 'n' to select none.
   8 //
   9
  10 #ifdef OSG_BUILD_ACTIVE
  11 // Headers
  12 #include <OSGGLUT.h>
  13 #include <OSGConfig.h>
  14 #include <OSGSimpleGeometry.h>
  15 #include <OSGGLUTWindow.h>
  16 #include <OSGSimpleSceneManager.h>
  17 #include <OSGBaseFunctions.h>
  18 #include <OSGTransform.h>
  19
  20 // new headers:
  21
  22 // the Switch node core
  23 #include <OSGSwitch.h>
  24 #else
  25 // Headers
  26 #include <OpenSG/OSGGLUT.h>
  27 #include <OpenSG/OSGConfig.h>
  28 #include <OpenSG/OSGSimpleGeometry.h>
  29 #include <OpenSG/OSGGLUTWindow.h>
  30 #include <OpenSG/OSGSimpleSceneManager.h>
  31 #include <OpenSG/OSGBaseFunctions.h>
  32 #include <OpenSG/OSGTransform.h>
  33
  34 // new headers:
  35
  36 // the Switch node core
  37 #include <OpenSG/OSGSwitch.h>
  38 #endif
  39
  40
  41 // the Switch Core
  42 OSG::SwitchRefPtr sw;
  43
  44 // number of copies to create
  45 const OSG::UInt16 ncopies = 10;
  46
  47 // Transforms to move the nodes
  48 OSG::TransformRefPtr trans[ncopies];
  49
  50
  51 // The SimpleSceneManager to manage simple applications
  52 OSG::SimpleSceneManagerRefPtr mgr;
  53
  54 // forward declaration so we can have the interesting stuff upfront
  55 int setupGLUT( int *argc, char *argv[] );
  56
  57 // redraw the window
  58 void display( void )
  59 {
  60     // create the matrix
  61     OSG::Matrix m;
  62     OSG::Real32 t = glutGet(GLUT_ELAPSED_TIME );
  63
  64     // set the transforms' matrices
  65     for(OSG::UInt16 i=0; i<ncopies; ++i)
  66     {
  67         m.setTransform(
  68             OSG::Vec3f(OSG::osgSin(t / 1000.f + i * 4 * ncopies / OSG::Pi),
  69                        OSG::osgCos(t / 1000.f + i * 6 * ncopies / OSG::Pi),
  70                        OSG::osgSin(t / 1000.f + i * 7 * ncopies / OSG::Pi)),
  71             OSG::Quaternion(OSG::Vec3f (1,1,0),
  72                             t / 1000.f + i * 4 * ncopies / OSG::Pi));
  73
  74         trans[i]->setMatrix(m);
  75     }
  76
  77     OSG::commitChanges();
  78
  79     mgr->redraw();
  80 }
  81
  82 void update(void)
  83 {
  84     glutPostRedisplay();
  85 }
  86
  87 // Initialize GLUT & OpenSG and set up the scene
  88 int main(int argc, char **argv)
  89 {
  90     // OSG init
  91     OSG::osgInit(argc,argv);
  92
  93     // GLUT init
  94     int winid = setupGLUT(&argc, argv);
  95
  96     // open a new scope, because the pointers below should go out of scope
  97     // before entering glutMainLoop.
  98     // Otherwise OpenSG will complain about objects being alive after shutdown.
  99     {
 100
 101         // the connection between GLUT and OpenSG
 102         OSG::GLUTWindowRefPtr gwin = OSG::GLUTWindow::create();
 103         gwin->setGlutId(winid);
 104         gwin->init();
 105
 106         // create the scene
 107
 108         // this time, create just the core of the geometry
 109         OSG::GeometryRefPtr torus = OSG::makeTorusGeo( .5, 2, 8, 12 );
 110
 111         // create the scene
 112         // the scene has a single group with ncopies transformations below,
 113         // each of these carries a Node that shares the geometry
 114
 115         /*
 116         The Switch NodeCore very similar to the Group, but it has the additional
 117         capability to only show one or none of its children.
 118
 119         This is controlled by the choice Field, and is used below in the keys
 120         function.
 121         */
 122
 123         // create the root Switch node
 124         OSG::NodeRefPtr  scene = OSG::Node::create();
 125
 126         sw = OSG::Switch::create();
 127         sw->setChoice(OSG::Switch::ALL);
 128
 129         scene->setCore(sw);
 130
 131         // create the copied geometry nodes and their transformations
 132         for(OSG::UInt16 i = 0; i<ncopies; ++i)
 133         {
 134             // create the nodes for the shared Geometry core
 135             OSG::NodeRefPtr geonode = OSG::Node::create();
 136
 137             // assign the Core to the Node
 138             geonode->setCore(torus);
 139
 140             // add a transformation for every Geometry
 141             OSG::NodeRefPtr transnode = OSG::Node::create();
 142
 143             trans[i] = OSG::Transform::create();
 144
 145             transnode->setCore (trans[i]);
 146             transnode->addChild(geonode );
 147
 148             scene->addChild(transnode);
 149         }
 150
 151         OSG::commitChanges();
 152
 153         // create the SimpleSceneManager helper
 154         mgr = OSG::SimpleSceneManager::create();
 155
 156         // tell the manager what to manage
 157         mgr->setWindow(gwin );
 158         mgr->setRoot  (scene);
 159
 160         // show the whole scene
 161         mgr->showAll();
 162     }
 163
 164     // GLUT main loop
 165     glutMainLoop();
 166
 167     return 0;
 168 }
 169
 170 //
 171 // GLUT callback functions
 172 //
 173
 174 // react to size changes
 175 void reshape(int w, int h)
 176 {
 177     mgr->resize(w, h);
 178     glutPostRedisplay();
 179 }
 180
 181 // react to mouse button presses
 182 void mouse(int button, int state, int x, int y)
 183 {
 184     if (state)
 185         mgr->mouseButtonRelease(button, x, y);
 186     else
 187         mgr->mouseButtonPress(button, x, y);
 188
 189     glutPostRedisplay();
 190 }
 191
 192 // react to mouse motions with pressed buttons
 193 void motion(int x, int y)
 194 {
 195     mgr->mouseMove(x, y);
 196     glutPostRedisplay();
 197 }
 198
 199 // react to keys
 200 void keyboard(unsigned char k, int , int )
 201 {
 202     switch(k)
 203     {
 204         case 27:
 205         {
 206             // clean up global variables
 207             for(OSG::UInt32 i = 0; i < ncopies; ++i)
 208                 trans[i] = NULL;
 209
 210             sw  = NULL;
 211             mgr = NULL;
 212
 213             OSG::osgExit();
 214             exit(1);
 215         }
 216         break;
 217
 218         case '0':   case '1':   case '2':   case '3':   case '4':
 219         case '5':   case '6':   case '7':   case '8':   case '9':
 220         {
 221             sw->setChoice(k - '0');
 222             break;
 223         }
 224         break;
 225
 226         case 'a':
 227         {
 228             sw->setChoice(OSG::Switch::ALL);
 229         }
 230         break;
 231
 232         case 'n':
 233         {
 234             sw->setChoice(OSG::Switch::NONE);
 235         }
 236         break;
 237     }
 238 }
 239
 240 // setup the GLUT library which handles the windows for us
 241 int setupGLUT(int *argc, char *argv[])
 242 {
 243     glutInit(argc, argv);
 244     glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
 245
 246     int winid = glutCreateWindow("OpenSG");
 247
 248     glutReshapeFunc(reshape);
 249     glutDisplayFunc(display);
 250     glutMouseFunc(mouse);
 251     glutMotionFunc(motion);
 252     glutKeyboardFunc(keyboard);
 253
 254     // call the redraw function whenever there's nothing else to do
 255     glutIdleFunc(update);
 256
 257     return winid;
 258 }