Examples/Simple/03share.cpp

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