// Initialize GLUT & OpenSG and set up the scene
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
getDefaultVideoManager()->init(argc, argv);
TheVideo = getDefaultVideoManager()->createVideoWrapper();
TutorialVideoListener TheVideoListener;
TheVideo->addVideoListener(&TheVideoListener);
//TheVideo->open(Path("./Data/ExampleVideo.avi"));
TheVideo->open(Path("./Data/ExampleVideo.avi"));
TheVideo->pause();
// GLUT init
int winid = setupGLUT(&argc, argv);
// the connection between GLUT and OpenSG
GLUTWindowPtr gwin= GLUTWindow::create();
gwin->setId(winid);
gwin->init();
// create the scene
TheVideo->updateImage();
Real32 AspectRatio(static_cast<Real32>(TheVideo->getImage()->getWidth())/static_cast<Real32>(TheVideo->getImage()->getHeight()));
MaterialPtr VideoMaterial = createVideoMaterial();
//Plane Geometry
GeometryPtr PlaneGeometry = makePlaneGeo(10.0*AspectRatio,10.0,10,10);
beginEditCP(PlaneGeometry, Geometry::MaterialFieldMask);
PlaneGeometry->setMaterial(VideoMaterial);
endEditCP(PlaneGeometry, Geometry::MaterialFieldMask);
NodePtr PlaneGeometryNode = Node::create();
beginEditCP(PlaneGeometryNode, Node::CoreFieldMask);
PlaneGeometryNode->setCore(PlaneGeometry);
endEditCP(PlaneGeometryNode, Node::CoreFieldMask);
//Box Geometry
GeometryPtr BoxGeometry = makeBoxGeo(10.0*AspectRatio,10.0,10.0,2,2,2);
beginEditCP(BoxGeometry, Geometry::MaterialFieldMask);
BoxGeometry->setMaterial(VideoMaterial);
endEditCP(BoxGeometry, Geometry::MaterialFieldMask);
NodePtr BoxGeometryNode = Node::create();
beginEditCP(BoxGeometryNode, Node::CoreFieldMask);
BoxGeometryNode->setCore(BoxGeometry);
endEditCP(BoxGeometryNode, Node::CoreFieldMask);
//Sphere Geometry
GeometryPtr SphereGeometry = makeSphereGeo(2,5.0);
beginEditCP(SphereGeometry, Geometry::MaterialFieldMask);
SphereGeometry->setMaterial(VideoMaterial);
endEditCP(SphereGeometry, Geometry::MaterialFieldMask);
NodePtr SphereGeometryNode = Node::create();
beginEditCP(SphereGeometryNode, Node::CoreFieldMask);
SphereGeometryNode->setCore(SphereGeometry);
endEditCP(SphereGeometryNode, Node::CoreFieldMask);
//Torus Geometry
GeometryPtr TorusGeometry = makeTorusGeo(2.0,5.0,32,32);
beginEditCP(TorusGeometry, Geometry::MaterialFieldMask);
TorusGeometry->setMaterial(VideoMaterial);
endEditCP(TorusGeometry, Geometry::MaterialFieldMask);
NodePtr TorusGeometryNode = Node::create();
beginEditCP(TorusGeometryNode, Node::CoreFieldMask);
TorusGeometryNode->setCore(TorusGeometry);
endEditCP(TorusGeometryNode, Node::CoreFieldMask);
//Switch Node
GeometryNodeSwitch = Switch::create();
beginEditCP(GeometryNodeSwitch, Switch::ChoiceFieldMask);
GeometryNodeSwitch->setChoice(0);
endEditCP(GeometryNodeSwitch, Switch::ChoiceFieldMask);
SwitchNode = Node::create();
beginEditCP(SwitchNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
SwitchNode->setCore(GeometryNodeSwitch);
SwitchNode->addChild(PlaneGeometryNode);
SwitchNode->addChild(BoxGeometryNode);
SwitchNode->addChild(SphereGeometryNode);
SwitchNode->addChild(TorusGeometryNode);
endEditCP(SwitchNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
NodePtr scene = Node::create();
trans = Transform::create();
beginEditCP(scene, Node::CoreFieldMask | Node::ChildrenFieldMask);
{
scene->setCore(trans);
scene->addChild(SwitchNode);
}
endEditCP (scene, Node::CoreFieldMask | Node::ChildrenFieldMask);
// To check OpenGL extensions, the Window needs to have run through
// frameInit at least once. This automatically happens when rendering,
// but we don't don't to wait for that here.
gwin->activate();
gwin->frameInit();
// Now we can check for OpenGL extensions
hasNPOT = gwin->hasExtension("GL_ARB_texture_rectangle");
// 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"
<< endLog;
// create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// tell the manager what to manage
mgr->setWindow(gwin );
mgr->setRoot (scene);
mgr->setStatistics(true);
// show the whole scene
mgr->showAll();
//Start playing video
TheVideo->play();
// GLUT main loop
glutMainLoop();
//DeInit
TheVideo->stop();
TheVideo->close();
getDefaultVideoManager()->exit();
osgExit();
return 0;
}
void PlaneMoveManipulator::onCreate(const PlaneMoveManipulator* source)
{
// Skip direct parent, don't want the default geometry creation
Transform::onCreate(source);
SimpleMaterialUnrecPtr pMat = SimpleMaterial::create();
pMat->setDiffuse(Color3f(.5, .5, .5));
pMat->setLit (false );
setMaterialX(pMat);
pMat = SimpleMaterial::create();
pMat->setDiffuse(Color3f(0, 1, 0));
pMat->setLit (false );
LineChunkUnrecPtr lc = LineChunk::create();
lc->setWidth(3);
pMat->addChunk(lc);
setMaterialY(pMat);
pMat = SimpleMaterial::create();
pMat->setDiffuse(Color3f(0., 0., 1.));
pMat->setLit (true );
setMaterialZ(pMat);
// SimpleMaterial *simpleMat;
// Geometry *geo;
setExternalUpdateHandler(NULL);
// add a name attachment
NameUnrecPtr nameN = Name::create();
nameN->editFieldPtr()->setValue("XYManipulator");
addAttachment(nameN);
// make the axis line. Not really a handle, but easier to manage this way.
GeoBuilder b;
b.vertex(Pnt3f(0,0,0));
b.vertex(Pnt3f(0,getLength()[1],0));
b.line(0, 1);
GeometryUnrecPtr g = b.getGeometry();
g->setMaterial(getMaterialY());
NodeUnrecPtr pNode = makeNodeFor(g);
setTransYNode(pNode);
// make the plane handle
pNode = Node::create();
setTransXNode(pNode);
g = makePlaneGeo(getLength()[0] / 2.f, getLength()[2] / 2.f, 1, 1);
g->setMaterial(getMaterialX());
pNode = makeNodeFor(g);
OSG::ComponentTransformUnrecPtr transHandleXC = ComponentTransform::create();
setHandleXNode(pNode);
getTransXNode()->setCore (transHandleXC );
getTransXNode()->addChild(getHandleXNode());
transHandleXC->setTranslation(Vec3f(0, getLength()[1], 0));
transHandleXC->setRotation (Quaternion(Vec3f(1, 0, 0), osgDegree2Rad(90)));
//
// make the rotate handle
pNode = Node::create();
setTransZNode(pNode);
g = makeCylinderGeo(0.05f, 0.1f, 16, true, true, true);
g->setMaterial(getMaterialZ());
pNode = makeNodeFor(g);
OSG::ComponentTransformUnrecPtr transHandleZC = ComponentTransform::create();
setHandleZNode(pNode);
getTransZNode()->setCore (transHandleZC );
getTransZNode()->addChild(getHandleZNode());
transHandleZC->setTranslation(Vec3f(0, getLength()[1], 0));
commitChanges();
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
{
// Set up Window
WindowEventProducerRecPtr TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
// Create the SimpleSceneManager helper
SimpleSceneManager sceneManager;
TutorialWindow->setDisplayCallback(boost::bind(display, &sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, &sceneManager));
//Attach to events
TutorialWindow->connectMousePressed(boost::bind(mousePressed, _1, &sceneManager));
TutorialWindow->connectMouseReleased(boost::bind(mouseReleased, _1, &sceneManager));
TutorialWindow->connectMouseDragged(boost::bind(mouseDragged, _1, &sceneManager));
TutorialWindow->connectMouseWheelMoved(boost::bind(mouseWheelMoved, _1, &sceneManager));
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
VideoWrapperRecPtr TheVideo = getDefaultVideoManager()->createVideoWrapper();
TheVideo->attachUpdateProducer(TutorialWindow);
TheVideo->connectStarted(boost::bind(handleVideoStarted, _1));
TheVideo->connectPaused(boost::bind(handleVideoPaused, _1));
TheVideo->connectUnpaused(boost::bind(handleVideoUnpaused, _1));
TheVideo->connectStopped(boost::bind(handleVideoStopped, _1));
TheVideo->connectClosed(boost::bind(handleVideoClosed, _1));
TheVideo->connectSeeked(boost::bind(handleVideoSeeked, _1));
TheVideo->connectCycled(boost::bind(handleVideoCycled, _1));
TheVideo->connectOpened(boost::bind(handleVideoOpened, _1));
TheVideo->connectEnded(boost::bind(handleVideoEnded, _1));
BoostPath VideoFilePath("./Data/ExampleVideo.avi");
if(argc >= 2)
{
VideoFilePath = BoostPath(argv[1]);
if(!boost::filesystem::exists(VideoFilePath))
{
std::cerr << "Could not load file: "<< VideoFilePath.string()
<< ", because no such files exists."<< std::endl;
VideoFilePath = BoostPath("./Data/ExampleVideo.avi");
}
}
TheVideo->open(VideoFilePath, TutorialWindow);
TheVideo->pause();
if(TheVideo->hasAudio())
{
TheVideo->enableAudio();
TheVideo->setAudioVolume(0.5f);
}
//Wait for the video to initialize
std::cout << "Dimensions: " << TheVideo->getWidth()
<< "x" << TheVideo->getHeight()
<< std::endl;
Real32 AspectRatio(static_cast<Real32>(TheVideo->getWidth())/static_cast<Real32>(TheVideo->getHeight()));
//Real32 AspectRatio(4.0f/3.0f);
// 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).
//TheVideo->setMinFilter(GL_LINEAR);
TheVideo->setMinFilter(GL_NEAREST);
TheVideo->setMagFilter(GL_LINEAR);
//TheVideo->setMagFilter(GL_NEAREST);
// Set the wrapping modes. We don't need repetition, it might actually
// introduce artifactes at the borders, so switch it off.
TheVideo->setWrapS(GL_CLAMP_TO_EDGE);
TheVideo->setWrapT(GL_CLAMP_TO_EDGE);
TheVideo->setScale(false);
ChunkMaterialUnrecPtr VideoMaterial = ChunkMaterial::create();
VideoMaterial->addChunk(TheVideo);
StateChunkUnrecPtr pMChunk = MaterialChunk::create();
VideoMaterial->addChunk(pMChunk);
// create the scene
//Plane Geometry
GeometryRecPtr PlaneGeometry = makePlaneGeo(10.0*AspectRatio,10.0,10,10);
PlaneGeometry->setMaterial(VideoMaterial);
NodeRecPtr PlaneGeometryNode = Node::create();
PlaneGeometryNode->setCore(PlaneGeometry);
//Box Geometry
GeometryRecPtr BoxGeometry = makeBoxGeo(10.0*AspectRatio,10.0,10.0,2,2,2);
BoxGeometry->setMaterial(VideoMaterial);
NodeRecPtr BoxGeometryNode = Node::create();
BoxGeometryNode->setCore(BoxGeometry);
//Sphere Geometry
GeometryRecPtr SphereGeometry = makeSphereGeo(2,5.0);
SphereGeometry->setMaterial(VideoMaterial);
NodeRecPtr SphereGeometryNode = Node::create();
SphereGeometryNode->setCore(SphereGeometry);
//Torus Geometry
GeometryRecPtr TorusGeometry = makeTorusGeo(2.0,5.0,32,32);
TorusGeometry->setMaterial(VideoMaterial);
NodeRecPtr TorusGeometryNode = Node::create();
TorusGeometryNode->setCore(TorusGeometry);
//Switch Node
SwitchRecPtr GeometryNodeSwitch = Switch::create();
GeometryNodeSwitch->setChoice(0);
NodeRecPtr SwitchNode = Node::create();
SwitchNode->setCore(GeometryNodeSwitch);
SwitchNode->addChild(PlaneGeometryNode);
SwitchNode->addChild(BoxGeometryNode);
SwitchNode->addChild(SphereGeometryNode);
SwitchNode->addChild(TorusGeometryNode);
NodeRecPtr scene = Node::create();
TransformRecPtr trans = Transform::create();
scene->setCore(trans);
scene->addChild(SwitchNode);
TutorialWindow->connectKeyTyped(boost::bind(handleKeyTyped, _1, TheVideo.get(), GeometryNodeSwitch.get()));
sceneManager.setRoot(scene);
// Show the whole Scene
sceneManager.showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"01PlayVideo");
commitChanges();
//Enter main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
