Examples/Simple/07multiindexgeometry.cpp

   1 // OpenSG Tutorial Example: Multiindex Geometry
   2 //
   3 // This example shows how to use an index mapping to use different indices
   4 // for different attributes.
   5 //
   6
   7 #ifdef OSG_BUILD_ACTIVE
   8 // Headers
   9 #include <OSGGLUT.h>
  10 #include <OSGConfig.h>
  11 #include <OSGSimpleGeometry.h>
  12 #include <OSGGeoProperties.h>
  13 #include <OSGGLUTWindow.h>
  14 #include <OSGSimpleSceneManager.h>
  15 #include <OSGBaseFunctions.h>
  16 #include <OSGTransform.h>
  17 #include <OSGGroup.h>
  18 #include <OSGGeometry.h>
  19 #else
  20 // Headers
  21 #include <OpenSG/OSGGLUT.h>
  22 #include <OpenSG/OSGConfig.h>
  23 #include <OpenSG/OSGSimpleGeometry.h>
  24 #include <OpenSG/OSGGeoProperties.h>
  25 #include <OpenSG/OSGGLUTWindow.h>
  26 #include <OpenSG/OSGSimpleSceneManager.h>
  27 #include <OpenSG/OSGBaseFunctions.h>
  28 #include <OpenSG/OSGTransform.h>
  29 #include <OpenSG/OSGGroup.h>
  30 #include <OpenSG/OSGGeometry.h>
  31 #endif
  32
  33 // The pointer to the transformation
  34 OSG::TransformRefPtr trans;
  35
  36 // The SimpleSceneManager to manage simple applications
  37 OSG::SimpleSceneManagerRefPtr mgr;
  38
  39 // forward declaration so we can have the interesting stuff upfront
  40 int setupGLUT( int *argc, char *argv[] );
  41
  42 // redraw the window
  43 void display( void )
  44 {
  45     // create the matrix
  46     OSG::Matrix m;
  47     OSG::Real32 t = glutGet(GLUT_ELAPSED_TIME );
  48
  49     m.setTransform(OSG::Quaternion(OSG::Vec3f(0,1,0), t / 1000.f));
  50
  51     // set the transform's matrix
  52     trans->setMatrix(m);
  53
  54     OSG::commitChanges();
  55
  56     mgr->redraw();
  57 }
  58
  59 // Initialize GLUT & OpenSG and set up the scene
  60 int main(int argc, char **argv)
  61 {
  62     // OSG init
  63     OSG::osgInit(argc,argv);
  64
  65     // GLUT init
  66     int winid = setupGLUT(&argc, argv);
  67
  68     /*
  69        open a new scope, because the pointers below should go out of scope
  70        before entering glutMainLoop.
  71        Otherwise OpenSG will complain about objects being alive after shutdown.
  72     */
  73     {
  74         // the connection between GLUT and OpenSG
  75         OSG::GLUTWindowRefPtr gwin = OSG::GLUTWindow::create();
  76         gwin->setGlutId(winid);
  77         gwin->init();
  78
  79         /*
  80            create the scene
  81
  82            In the previous example, the colors and positions used the same
  83            indices. That might not always be the preferred way, and it might not
  84            make sense for other properties, e.g. normals.
  85
  86            It is possible to assign a different index for every property. See the
  87            indices section below for details.
  88
  89
  90            The initial setup is the same as in 06indexgeometry
  91         */
  92
  93         OSG::GeoUInt8PropertyRefPtr type = OSG::GeoUInt8Property::create();
  94         type->addValue(GL_POLYGON  );
  95         type->addValue(GL_TRIANGLES);
  96         type->addValue(GL_QUADS    );
  97
  98         OSG::GeoUInt32PropertyRefPtr lens = OSG::GeoUInt32Property::create();
  99         lens->addValue(4);
 100         lens->addValue(6);
 101         lens->addValue(8);
 102
 103         // positions
 104         OSG::GeoPnt3fPropertyRefPtr pnts = OSG::GeoPnt3fProperty::create();
 105         // the base
 106         pnts->addValue(OSG::Pnt3f(-1, -1, -1));
 107         pnts->addValue(OSG::Pnt3f(-1, -1,  1));
 108         pnts->addValue(OSG::Pnt3f( 1, -1,  1));
 109         pnts->addValue(OSG::Pnt3f( 1, -1, -1));
 110
 111         // the roof base
 112         pnts->addValue(OSG::Pnt3f(-1,  0, -1));
 113         pnts->addValue(OSG::Pnt3f(-1,  0,  1));
 114         pnts->addValue(OSG::Pnt3f( 1,  0,  1));
 115         pnts->addValue(OSG::Pnt3f( 1,  0, -1));
 116
 117         // the gable
 118         pnts->addValue(OSG::Pnt3f( 0,  1, -1));
 119         pnts->addValue(OSG::Pnt3f( 0,  1,  1));
 120
 121         // colors
 122         OSG::GeoVec3fPropertyRefPtr colors = OSG::GeoVec3fProperty::create();
 123         colors->push_back(OSG::Color3f(1, 1, 0));
 124         colors->push_back(OSG::Color3f(1, 0, 0));
 125         colors->push_back(OSG::Color3f(1, 0, 0));
 126         colors->push_back(OSG::Color3f(1, 1, 0));
 127         colors->push_back(OSG::Color3f(0, 1, 1));
 128         colors->push_back(OSG::Color3f(1, 0, 1));
 129
 130         /*
 131            A new property: normals.
 132
 133            They are used for lighting calculations and have to point away from the
 134            surface. Normals are standard vectors.
 135         */
 136
 137         OSG::GeoVec3fPropertyRefPtr norms = OSG::GeoVec3fProperty::create();
 138         norms->push_back(OSG::Vec3f(-1,  0,  0));
 139         norms->push_back(OSG::Vec3f( 1,  0,  0));
 140         norms->push_back(OSG::Vec3f( 0, -1,  0));
 141         norms->push_back(OSG::Vec3f( 0,  1,  0));
 142         norms->push_back(OSG::Vec3f( 0,  0, -1));
 143         norms->push_back(OSG::Vec3f( 0,  0,  1));
 144
 145         /*
 146            To use more than one index for a geometry, create multiple
 147            GeoUInt32Property (or GeoUInt8Property or GeoUInt16Property) objects
 148            and add them as index for the corresponding property you want to
 149            index.
 150         */
 151
 152         OSG::GeoUInt32PropertyRefPtr ind1 = OSG::GeoUInt32Property::create();
 153         OSG::GeoUInt32PropertyRefPtr ind2 = OSG::GeoUInt32Property::create();
 154
 155         // fill first index (will be used for positions)
 156         ind1->push_back(0);     // polygon
 157         ind1->push_back(1);
 158         ind1->push_back(2);
 159         ind1->push_back(3);
 160
 161         ind1->push_back(7);     // triangle 1
 162         ind1->push_back(4);
 163         ind1->push_back(8);
 164         ind1->push_back(5);     // triangle 2
 165         ind1->push_back(6);
 166         ind1->push_back(9);
 167
 168         ind1->push_back(1);     // quad 1
 169         ind1->push_back(2);
 170         ind1->push_back(6);
 171         ind1->push_back(5);
 172         ind1->push_back(3);     // quad 2
 173         ind1->push_back(0);
 174         ind1->push_back(4);
 175         ind1->push_back(7);
 176
 177         // fill second index (will be used for colors/normals)
 178         ind2->push_back(3);     // polygon
 179         ind2->push_back(3);
 180         ind2->push_back(3);
 181         ind2->push_back(3);
 182
 183         ind2->push_back(4);     // triangle 1
 184         ind2->push_back(4);
 185         ind2->push_back(4);
 186         ind2->push_back(5);     // triangle 2
 187         ind2->push_back(5);
 188         ind2->push_back(5);
 189
 190         ind2->push_back(5);     // quad 1
 191         ind2->push_back(5);
 192         ind2->push_back(5);
 193         ind2->push_back(5);
 194         ind2->push_back(4);     // quad 2
 195         ind2->push_back(4);
 196         ind2->push_back(4);
 197         ind2->push_back(4);
 198
 199
 200         /*
 201             Put it all together into a Geometry NodeCore.
 202         */
 203         OSG::GeometryRefPtr geo = OSG::Geometry::create();
 204         geo->setTypes    (type);
 205         geo->setLengths  (lens);
 206
 207         /*
 208            Set the properties and indices used to index them.
 209            Calling geo->setProperty(pnts, Geometry::PositionsIndex) is the
 210            same as calling geo->setPositions(pnts), but this way it is
 211            more obvious which properties and indices go together.
 212         */
 213
 214         geo->setProperty(pnts,   OSG::Geometry::PositionsIndex);
 215         geo->setIndex   (ind1,   OSG::Geometry::PositionsIndex);
 216
 217         geo->setProperty(norms,  OSG::Geometry::NormalsIndex  );
 218         geo->setIndex   (ind2,   OSG::Geometry::NormalsIndex  );
 219
 220         geo->setProperty(colors, OSG::Geometry::ColorsIndex   );
 221         geo->setIndex   (ind2,   OSG::Geometry::ColorsIndex   );
 222
 223         geo->setMaterial (OSG::getDefaultMaterial());
 224
 225         // put the geometry core into a node
 226         OSG::NodeRefPtr n = OSG::Node::create();
 227         n->setCore(geo);
 228
 229         // add a transformation to make it move
 230         OSG::NodeRefPtr scene = OSG::Node::create();
 231         trans = OSG::Transform::create();
 232         scene->setCore(trans);
 233         scene->addChild(n);
 234
 235         OSG::commitChanges();
 236
 237         // create the SimpleSceneManager helper
 238         mgr = OSG::SimpleSceneManager::create();
 239
 240         // tell the manager what to manage
 241         mgr->setWindow(gwin );
 242         mgr->setRoot  (scene);
 243
 244         // show the whole scene
 245         mgr->showAll();
 246     }
 247
 248     // GLUT main loop
 249     glutMainLoop();
 250
 251     return 0;
 252 }
 253
 254 //
 255 // GLUT callback functions
 256 //
 257
 258 // react to size changes
 259 void reshape(int w, int h)
 260 {
 261     mgr->resize(w, h);
 262     glutPostRedisplay();
 263 }
 264
 265 // react to mouse button presses
 266 void mouse(int button, int state, int x, int y)
 267 {
 268     if (state)
 269         mgr->mouseButtonRelease(button, x, y);
 270     else
 271         mgr->mouseButtonPress(button, x, y);
 272
 273     glutPostRedisplay();
 274 }
 275
 276 // react to mouse motions with pressed buttons
 277 void motion(int x, int y)
 278 {
 279     mgr->mouseMove(x, y);
 280     glutPostRedisplay();
 281 }
 282
 283 // react to keys
 284 void keyboard(unsigned char k, int x, int y)
 285 {
 286     switch(k)
 287     {
 288         case 27:
 289         {
 290             // clean up global variables
 291             trans = NULL;
 292             mgr   = NULL;
 293
 294             OSG::osgExit();
 295             exit(0);
 296         }
 297         break;
 298
 299         case 's':
 300         {
 301             mgr->setStatistics(!mgr->getStatistics());
 302         }
 303         break;
 304     }
 305 }
 306
 307 // setup the GLUT library which handles the windows for us
 308 int setupGLUT(int *argc, char *argv[])
 309 {
 310     glutInit(argc, argv);
 311     glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
 312
 313     int winid = glutCreateWindow("OpenSG");
 314
 315     glutReshapeFunc(reshape);
 316     glutDisplayFunc(display);
 317     glutMouseFunc(mouse);
 318     glutMotionFunc(motion);
 319     glutKeyboardFunc(keyboard);
 320
 321     // call the redraw function whenever there's nothing else to do
 322     glutIdleFunc(display);
 323
 324     return winid;
 325 }