// react to keys
void keyboard(unsigned char k, int , int )
{
switch(k)
{
case 27:
onExit();
OSG::osgExit();
exit(0);
break;
case 'f':
g_mgr->setNavigationMode(OSG::Navigator::FLY);
break;
case 't':
g_mgr->setNavigationMode(OSG::Navigator::TRACKBALL);
break;
case 'q':
g_mgr->setStatistics(true);
break;
case 'w':
g_mgr->setStatistics(false);
break;
case 'r':
{
bool useTrav = !g_mgr->getUseTraversalAction();
g_mgr->setUseTraversalAction(useTrav);
printf("Using %s action.\n", useTrav ? "render traversal" : "render");
}
break;
}
}
// react to keys
void keyboard(unsigned char k, int x, int y)
{
switch(k)
{
case 'e':
{
// clean up global variables
mgr = NULL;
OSG::osgExit();
exit(0);
}
break;
case 's':
{
mgr->setStatistics(!mgr->getStatistics());
}
break;
}
}
//
// react to keys
//
void keyboard(unsigned char k, int x, int y)
{
switch(k)
{
case 27:
{
// clean up global variables
cyltrans = NULL;
tortrans = NULL;
mgr = NULL;
ubo_light_state = NULL;
ubo_geom_state_1 = NULL;
ubo_geom_state_2 = NULL;
OSG::osgExit();
exit(0);
}
break;
case 'm':
{
GeomState geom1; geom1.material_index = dist(generator);
GeomState geom2; geom2.material_index = dist(generator);
update_geometry_material_state(ubo_geom_state_1, geom1);
update_geometry_material_state(ubo_geom_state_2, geom2);
glutPostRedisplay();
}
break;
case 's':
{
mgr->setStatistics(!mgr->getStatistics());
}
break;
}
}
// react to keys
void keyboard(unsigned char k, int , int )
{
switch(k)
{
case 27:
{
cleanup();
OSG::osgExit();
std::exit(0);
}
break;
case 'f':
{
mgr->setNavigationMode(OSG::Navigator::FLY);
std::cout << "Fly mode" << std::endl;
}
break;
case 't':
{
mgr->setNavigationMode(OSG::Navigator::TRACKBALL);
std::cout << "Trackball mode" << std::endl;
}
break;
case 'q':
{
mgr->setStatistics(!mgr->getStatistics());
std::cout << "Statistics "
<< (mgr->getStatistics() ? "enabled" : "disabled")
<< std::endl;
}
break;
case 'h':
{
mgr->setHeadlight(!mgr->getHeadlightState());
std::cout << "Headlight "
<< (mgr->getHeadlightState() ? "enabled" : "disabled")
<< std::endl;
}
break;
case 'b':
{
if(polyChunk == NULL)
{
polyChunk = OSG::PolygonChunk::create();
root->addChunk(polyChunk);
}
if(polyChunk->getCullFace() == GL_NONE)
{
polyChunk->setCullFace(GL_BACK);
std::cout << "Backface culling enabled" << std::endl;
}
else
{
polyChunk->setCullFace(GL_NONE);
std::cout << "Backface culling disabled" << std::endl;
}
}
break;
case 'w':
{
if(polyChunk == NULL)
{
polyChunk = OSG::PolygonChunk::create();
root->addChunk(polyChunk);
}
if(polyChunk->getFrontMode() == GL_FILL)
{
polyChunk->setFrontMode(GL_LINE);
polyChunk->setBackMode (GL_LINE);
std::cout << "Wireframe enabled" << std::endl;
}
else
{
polyChunk->setFrontMode(GL_FILL);
polyChunk->setBackMode (GL_FILL);
std::cout << "Wireframe disabled" << std::endl;
}
}
break;
case 'n':
{
if(normalsActive == true)
{
normalsActive = false;
NodeStore::const_iterator ngIt = normalsGeoN.begin();
NodeStore::const_iterator ngEnd = normalsGeoN.end ();
for(; ngIt != ngEnd; ++ngIt)
{
(*ngIt)->setTravMask(0);
}
std::cout << "Normals disabled" << std::endl;
}
else
{
normalsActive = true;
if(normalsGeoN.empty() == true)
constructNormalsGeo(sceneN);
NodeStore::const_iterator ngIt = normalsGeoN.begin();
NodeStore::const_iterator ngEnd = normalsGeoN.end ();
for(; ngIt != ngEnd; ++ngIt)
{
(*ngIt)->setTravMask(OSG::TypeTraits<OSG::UInt32>::BitsSet);
}
std::cout << "Normals enabled" << std::endl;
}
}
break;
case 'm':
{
normalsLen /= 1.25f;
constructNormalsGeo(sceneN);
std::cout << "Normals length " << normalsLen << std::endl;
}
break;
case 'M':
{
normalsLen *= 1.25f;
constructNormalsGeo(sceneN);
std::cout << "Normals length " << normalsLen << std::endl;
}
break;
case 'v':
{
mgr->getRenderAction()->setVolumeDrawing(
!mgr->getRenderAction()->getVolumeDrawing());
std::cout << "Volume drawing: "
<< (mgr->getRenderAction()->getVolumeDrawing() ? "enabled" : "disabled")
<< std::endl;
}
break;
case 'p':
{
OSG::SceneGraphPrinter sgp(mgr->getRoot());
sgp.addPrintFunc(OSG::SkinnedGeometry::getClassType(),
&printVolume );
sgp.printDownTree(std::cout);
NodeStore::const_iterator nIt = skinnedGeoN.begin();
NodeStore::const_iterator nEnd = skinnedGeoN.end ();
for(OSG::UInt32 i = 0; nIt != nEnd; ++nIt, ++i)
{
OSG::SkinnedGeometry *sgeo = dynamic_cast<OSG::SkinnedGeometry *>(
(*nIt)->getCore());
std::cout << "Skeleton:\n";
OSG::SceneGraphPrinter skelPrinter(sgeo->getSkeleton()->getRoots(0));
skelPrinter.addPrintFunc(OSG::Transform ::getClassType(),
&printXForm );
//skelPrinter.addPrintFunc(OSG::SkeletonJoint::getClassType(),
// &printJoint );
skelPrinter.printDownTree(std::cout);
}
}
break;
case 'a':
{
mgr->showAll();
std::cout << "Showing all of scene." << std::endl;
}
break;
case '[':
{
if(anims.empty() == false)
{
currAnim -= 1;
if(currAnim < 0)
currAnim = anims.size() - 1;
std::cout << "Current anim [" << currAnim << "] - ["
<< anims[currAnim].anim->getTemplate()->getName()
<< "]" << std::endl;
}
}
break;
case ']':
{
if(anims.empty() == false)
{
currAnim += 1;
if(currAnim >= OSG::Int32(anims.size()))
currAnim = 0;
std::cout << "Current anim [" << currAnim << "] - ["
<< anims[currAnim].anim->getTemplate()->getName()
<< "]" << std::endl;
}
}
break;
case 'L':
{
toggleAnim(currAnim, false);
}
break;
case 'l':
{
toggleAnim(currAnim, true);
}
break;
case 'd':
{
NodeStore::const_iterator nIt = skinnedGeoN.begin();
NodeStore::const_iterator nEnd = skinnedGeoN.end ();
for(OSG::UInt32 i = 0; nIt != nEnd; ++nIt, ++i)
{
OSG::SkinnedGeometry *sgeo = dynamic_cast<OSG::SkinnedGeometry *>(
(*nIt)->getCore());
if(sgeo->getRenderMode() == OSG::SkinnedGeometry::RMSkinnedCPU)
{
std::cout << "Enabling SkinnedGeo GPU mode ["
<< sgeo << "]" << std::endl;
sgeo->setRenderMode(OSG::SkinnedGeometry::RMSkinnedGPU);
sgeo->setMaterial (matSkin);
}
else if(sgeo->getRenderMode() == OSG::SkinnedGeometry::RMSkinnedGPU)
{
std::cout << "Enabling SkinnedGeo SKELETON mode ["
<< sgeo << "]" << std::endl;
sgeo->setRenderMode(OSG::SkinnedGeometry::RMSkeleton);
sgeo->setMaterial (skinnedGeoMat[i]);
}
else if(sgeo->getRenderMode() == OSG::SkinnedGeometry::RMSkeleton)
{
std::cout << "Enabling SkinnedGeo UNSKINNED mode ["
<< sgeo << "]" << std::endl;
sgeo->setRenderMode(OSG::SkinnedGeometry::RMUnskinned);
sgeo->setMaterial (skinnedGeoMat[i]);
}
else
{
std::cout << "Enabling SkinnedGeo CPU mode ["
<< sgeo << "]" << std::endl;
sgeo->setRenderMode(OSG::SkinnedGeometry::RMSkinnedCPU);
sgeo->setMaterial(skinnedGeoMat[i]);
}
}
}
break;
case 'c':
{
mgr->getRenderAction()->setFrustumCulling(
!mgr->getRenderAction()->getFrustumCulling());
std::cout << "Frustum culling: "
<< (mgr->getRenderAction()->getFrustumCulling() ? "enabled" : "disabled")
<< std::endl;
}
break;
case 's':
{
NodeStore::const_iterator nIt = skinnedGeoN.begin();
NodeStore::const_iterator nEnd = skinnedGeoN.end ();
for(OSG::UInt32 i = 0; nIt != nEnd; ++nIt, ++i)
{
OSG::SkinnedGeometry *sgeo = dynamic_cast<OSG::SkinnedGeometry *>(
(*nIt)->getCore());
OSG::Skeleton *skel = sgeo->getSkeleton();
OSG::Skeleton::MFRootsType::const_iterator rIt =
skel->getMFRoots()->begin();
OSG::Skeleton::MFRootsType::const_iterator rEnd =
skel->getMFRoots()->end ();
for(OSG::UInt32 j = 0; rIt != rEnd; ++rIt, ++j)
{
std::cout << "Skeleton [" << i << "] @ [" << skel
<< "] root [" << j << "]\n";
OSG::SceneGraphPrinter sgp(*rIt);
sgp.printDownTree(std::cout);
std::cout << std::endl;
}
}
}
break;
default:
{
printHelp();
}
break;
}
glutPostRedisplay();
}
// react to keys
void keyboard(unsigned char k, int x, int y)
{
switch(k)
{
case 27:
{
// clean up global variables
mgr = NULL;
OSG::osgExit();
exit(1);
}
break;
case 'a': // activate all lights
{
for(OSG::UInt16 i = 0; i < nlights; ++i)
{
lights[i]->setOn(true);
}
}
break;
case 's': // deactivate all but the spot lights
{
for(OSG::UInt16 i = 0; i < nlights; ++i)
{
if(lights[i]->getTypeId() != OSG::SpotLight::getClassTypeId())
{
lights[i]->setOn(false);
}
else
{
lights[i]->setOn(true);
}
}
OSG::commitChanges();
}
break;
case 'd': // deactivate all but the directional lights
{
for(OSG::UInt16 i = 0; i < nlights; ++i)
{
if(lights[i]->getTypeId() !=
OSG::DirectionalLight::getClassTypeId())
{
lights[i]->setOn(false);
}
else
{
lights[i]->setOn(true);
}
}
OSG::commitChanges();
}
break;
case 'p': // deactivate all but the point lights
{
for(OSG::UInt16 i = 0; i < nlights; ++i)
{
if(lights[i]->getTypeId() != OSG::PointLight::getClassTypeId())
{
lights[i]->setOn(false);
}
else
{
lights[i]->setOn(true);
}
}
OSG::commitChanges();
}
break;
case 'S':
{
mgr->setStatistics(!mgr->getStatistics());
}
break;
}
}
// Initialize GLUT & OpenSG and set up the scene
int main(int argc, char **argv)
{
// OSG init
OSG::osgInit(argc,argv);
// GLUT init
int winid = setupGLUT(&argc, argv);
{
// the connection between GLUT and OpenSG
OSG::GLUTWindowRefPtr gwin = OSG::GLUTWindow::create();
gwin->setGlutId(winid);
gwin->init();
// create the scene
OSG::NodeRefPtr torus = OSG::makeTorus( .5, 2, 16, 32 );
OSG::NodeRefPtr scene = OSG::Node::create();
trans = OSG::Transform::create();
scene->setCore(trans);
scene->addChild(torus);
// Create the parts needed for the video background
OSG::UInt32 width = 640;
OSG::UInt32 height = 480;
// get the desired size from the command line
if(argc >= 3)
{
width = atoi(argv[1]);
height = atoi(argv[2]);
}
// To check OpenGL extensions, the Window needs to have run through
// frameInit at least once. This automatically happens when rendering,
// but we can't wait for that here.
gwin->activate ();
gwin->frameInit();
// Now we can check for OpenGL extensions
hasNPOT = gwin->hasExtension("GL_ARB_texture_non_power_of_two");
// Print what we've got
SLOG << "Got " << (isPOT?"":"non-") << "power-of-two images and "
<< (hasNPOT?"can":"cannot") << " use NPOT textures, changing "
<< (changeOnlyPart?"part":"all")
<< " of the screen"
<< std::endl;
// Ok, now for the meat of the code...
// first we need an Image to hold the picture(s) to show
image = OSG::Image::create();
// set the image's size and type, and allocate memory
// this example uses RGB. On some systems (e.g. Windows) BGR
// or BGRA might be faster, it depends on how the images are
// acquired
image->set(OSG::Image::OSG_RGB_PF, width, height);
// Now create the texture to be used for the background
texObj = OSG::TextureObjChunk::create();
// Associate image and texture
texObj->setImage(image);
// Set filtering modes. LINEAR is cheap and good if the image size
// changes very little (i.e. the window is about the same size as
// the images).
texObj->setMinFilter(GL_LINEAR);
texObj->setMagFilter(GL_LINEAR);
// Set the wrapping modes. We don't need repetition, it might actually
// introduce artifactes at the borders, so switch it off.
texObj->setWrapS(GL_CLAMP_TO_EDGE);
texObj->setWrapT(GL_CLAMP_TO_EDGE);
// Newer versions of OpenGL can handle NPOT textures directly.
// OpenSG will do that internally automatically.
//
// Older versions need POT textures. By default OpenSG
// will scale an NPOT texture to POT while defining it.
// For changing textures that's too slow.
// So tell OpenSG not to scale the image and adjust the texture
// coordinates used by the TextureBackground (see below).
texObj->setScale(false);
// Create the background
OSG::TextureBackgroundRefPtr back = OSG::TextureBackground::create();
// Set the texture to use
back->setTexture(texObj);
// if the image is NPOT and we don't have hardware support for it
// adjust the texture coordinates.
if(isPOT == false && hasNPOT == false)
{
OSG::UInt32 potWidth = OSG::osgNextPower2(width );
OSG::UInt32 potHeight = OSG::osgNextPower2(height);
OSG::Real32 tcRight = OSG::Real32(width ) / OSG::Real32(potWidth );
OSG::Real32 tcTop = OSG::Real32(height) / OSG::Real32(potHeight);
back->editMFTexCoords()->push_back(OSG::Vec2f( 0.f, 0.f));
back->editMFTexCoords()->push_back(OSG::Vec2f(tcRight, 0.f));
back->editMFTexCoords()->push_back(OSG::Vec2f(tcRight, tcTop));
back->editMFTexCoords()->push_back(OSG::Vec2f( 0.f, tcTop));
}
OSG::commitChanges();
// create the SimpleSceneManager helper
mgr = OSG::SimpleSceneManager::create();
// tell the manager what to manage
mgr->setWindow(gwin );
mgr->setRoot (scene);
mgr->setStatistics(true);
// replace the background
// This has to be done after the viewport has been created, which the
// SSM does in setRoot().
OSG::ViewportRefPtr vp = gwin->getPort(0);
vp->setBackground(back);
}
// show the whole scene
mgr->showAll();
// GLUT main loop
glutMainLoop();
return 0;
}