int main(int argc, char **argv)
{
// we need to load some relative images and geometry files.
// to make this work reliable (e.g. starting the tutorial via link)
// we use the argv[0] parameter.
#ifdef WIN32
std::string sep("\\");
#else
std::string sep("/");
#endif
std::string path = argv[0];
// remove app name
std::string::size_type i = path.rfind(sep);
if(i != std::string::npos)
path = path.substr(0, i);
// set the current dir to the application dir.
OSG::Directory::setCurrent(path.c_str());
// OSG init
OSG::osgInit(argc, argv);
/* Initialize GLUT state - glut will take any command line arguments that pertain to it or
X Windows - look at its documentation at http://reality.sgi.com/mjk/spec3/spec3.html */
glutInit(&argc, argv);
/* Select type of Display mode:
Double buffer
RGBA color
Alpha components supported (use GLUT_ALPHA)
Depth buffer */
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH );
/* get a 640 x 480 window */
//glutInitWindowSize(640, 480);
glutInitWindowSize(Width, Height);
/* the window starts at the upper left corner of the screen */
glutInitWindowPosition(300, 0);
/* Open a window */
window = glutCreateWindow("Oz, Mouse Control");
if (m_bFullscreen)
glutFullScreen();
glutSetCursor(GLUT_CURSOR_NONE);
glutDisplayFunc(&DrawGLScene);
// register all GLUT callback functions
glutIdleFunc(idleFunc);
/* Register the function called when our window is resized. */
glutReshapeFunc(ReSizeGLScene);
/* Register the function called when the keyboard is pressed. */
glutKeyboardFunc(keyPressed);
/* Register the function called when special keys (arrows, page down, etc) are pressed. */
//glutSpecialFunc(&specialKeyPressed);
glutMouseFunc(mouseFunc);
glutMotionFunc(motionFunc);
glutPassiveMotionFunc(motionFunc);
/* Initialize our window. */
InitGL(640, 480);
pwin = OSG::PassiveWindow::create();
pwin->init();
/*
All scene file loading is handled via the SceneFileHandler.
*/
world = OSG::SceneFileHandler::the()->read("Data/tie.wrl");
// create the main scene transformation node
// 1. create the Node
scene =OSG:: Node::create();
// 2. create the core
trans = OSG::Transform::create();
// 3. associate the core with the node
scene->setCore(trans);
scene->addChild(world); // add the world as a child
// create the SimpleSceneManager helper - it will be only partially used
mgr = new OSG::SimpleSceneManager;
// tell the manager what to manage
mgr->setWindow(pwin );
mgr->setRoot (scene);
if (pwin->getMFPort()->size() != 0)
{
OSG::PassiveBackgroundRefPtr bg = OSG::PassiveBackground::create();
vp = pwin->getPort(0);
cam = dynamic_cast<OSG::PerspectiveCamera *>(vp->getCamera());
newcam = OSG::MatrixCamera::create(); // the MatrixCamera will only be a slave to the OpenGL matrices
vp->setCamera(newcam); // replace the cam
vp->setBackground(bg); // keep OpenSG from deleting the background, we will do that ourselves
if(cam == NULL)
exit(1);
}
else
{
printf("Could not acquire pointer to camera !!\n");
exit(1);
}
OSG::commitChanges();
/* Start Event Processing Engine */
glutMainLoop();
return 1;
}
// 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;
}
