int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
// Set up Window
TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
TutorialWindow->setDisplayCallback(display);
TutorialWindow->setReshapeCallback(reshape);
//Add Window Listener
TutorialKeyListener TheKeyListener;
TutorialWindow->addKeyListener(&TheKeyListener);
TutorialMouseListener TheTutorialMouseListener;
TutorialMouseMotionListener TheTutorialMouseMotionListener;
TutorialWindow->addMouseListener(&TheTutorialMouseListener);
TutorialWindow->addMouseMotionListener(&TheTutorialMouseMotionListener);
// Create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// Tell the Manager what to manage
mgr->setWindow(TutorialWindow);
//Shader Material
BlendChunkUnrecPtr ExampleBlendChunk = BlendChunk::create();
ExampleBlendChunk->setSrcFactor(GL_SRC_ALPHA);
ExampleBlendChunk->setDestFactor(GL_ONE_MINUS_SRC_ALPHA);
//Material Chunk
MaterialChunkUnrecPtr ShaderMaterialChunk = MaterialChunk::create();
ShaderMaterialChunk->setAmbient(Color4f(0.4f,0.4f,0.4f,1.0f));
ShaderMaterialChunk->setDiffuse(Color4f(0.7f,0.7f,0.7f,1.0f));
ShaderMaterialChunk->setSpecular(Color4f(1.0f,1.0f,1.0f,1.0f));
//Shader Chunk
SimpleSHLChunkUnrecPtr TheSHLChunk = SimpleSHLChunk::create();
TheSHLChunk->setVertexProgram(createSHLVertexProg());
TheSHLChunk->setFragmentProgram(createSHLFragProg());
//Color Parameter
ShaderVariableVec4fUnrecPtr Color1Parameter = ShaderVariableVec4f::create();
Color1Parameter->setName("Color1");
Color1Parameter->setValue(Vec4f(0.0f,1.0f,0.0f,1.0f));
ShaderVariableVec4fUnrecPtr Color2Parameter = ShaderVariableVec4f::create();
Color2Parameter->setName("Color2");
Color2Parameter->setValue(Vec4f(1.0f,1.0f,1.0f,1.0f));
//Shader Parameter Chunk
SHLParameterChunkUnrecPtr SHLParameters = SHLParameterChunk::create();
SHLParameters->getParameters().push_back(Color1Parameter);
SHLParameters->getParameters().push_back(Color2Parameter);
SHLParameters->setSHLChunk(TheSHLChunk);
ChunkMaterialUnrecPtr ShaderMaterial = ChunkMaterial::create();
ShaderMaterial->addChunk(ShaderMaterialChunk);
ShaderMaterial->addChunk(TheSHLChunk);
ShaderMaterial->addChunk(SHLParameters);
//Torus Node
GeometryUnrecPtr TorusGeometry = makeTorusGeo(5.0f,20.0f, 32,32);
TorusGeometry->setMaterial(ShaderMaterial);
NodeUnrecPtr TorusNode = Node::create();
TorusNode->setCore(TorusGeometry);
// Make Main Scene Node
NodeUnrecPtr scene = Node::create();
scene->setCore(Group::create());
scene->addChild(TorusNode);
mgr->setRoot(scene);
// Show the whole Scene
mgr->showAll();
//Create the Animations
initAnimations(Color1Parameter, "value");
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"04ShaderAnimation");
//Main Loop
TutorialWindow->mainLoop();
osgExit();
return 0;
}
int main(int argc, char **argv)
{
osgInit(argc,argv);
// GLUT init
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
glutCreateWindow("OpenSG");
glutReshapeFunc(reshape);
glutDisplayFunc(display);
glutIdleFunc(display);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutKeyboardFunc(keyboard);
PassiveWindowPtr pwin=PassiveWindow::create();
pwin->init();
// create the scene
NodePtr scene;
scene = Node::create();
// create the material
// Pass 1: Simple red, shiny, depth-tested
DepthChunkPtr cl1 = DepthChunk::create();
beginEditCP(cl1);
cl1->setEnable(true);
cl1->setFunc(GL_LEQUAL);
endEditCP(cl1);
SimpleMaterialPtr mat = SimpleMaterial::create();
beginEditCP(mat);
mat->setDiffuse(Color3f(1,0,0));
mat->setSpecular(Color3f(.9,.9,.9));
mat->setShininess(30);
mat->setLit(true);
mat->addChunk(cl1);
endEditCP(mat);
// Pass 2: Green unlit, without depth testing
DepthChunkPtr cl2 = DepthChunk::create();
beginEditCP(cl2);
cl2->setEnable(false);
endEditCP(cl2);
SimpleMaterialPtr mat2 = SimpleMaterial::create();
beginEditCP(mat2);
mat2->setDiffuse(Color3f(0,1,0));
mat2->setLit(false);
mat2->setTransparency(.8);
mat2->addChunk(cl2);
endEditCP(mat2);
// Bring them together
MultiPassMaterialPtr mpm = MultiPassMaterial::create();
beginEditCP(mpm);
mpm->editMFMaterials()->push_back(mat);
mpm->editMFMaterials()->push_back(mat2);
endEditCP(mpm);
GeometryPtr g1 = makeTorusGeo(0.2, 2, 8, 16);
beginEditCP(scene);
scene->setCore(g1);
endEditCP(scene);
beginEditCP(g1);
g1->setMaterial(mpm);
endEditCP(g1);
// create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// create the window and initial camera/viewport
mgr->setWindow(pwin );
// tell the manager what to manage
mgr->setRoot (scene);
// show the whole scene
mgr->showAll();
mgr->redraw();
// GLUT main loop
glutMainLoop();
return 0;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
{
TheLuaManager->init();
// 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));
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
//Setup the Lua Manager
BoostPath ModulePath("./Data/");
std::string PackagePath = std::string("?;")
+ (ModulePath / "?.lua" ).file_string() + ";"
+ (ModulePath / "?" / "init.lua").file_string();
TheLuaManager->setPackagePath(PackagePath);
// Make Torus Node (creates Torus in background of scene)
GeometryRefPtr TorusGeometry = makeTorusGeo(.5, 2, 16, 16);
setName(TorusGeometry,"Torus Geometry");
//calcVertexTangents(TorusGeometry,0,Geometry::TexCoords7FieldId, Geometry::TexCoords6FieldId);
NodeRefPtr TorusGeometryNode = Node::create();
setName(TorusGeometryNode,"Torus Geometry Node");
TorusGeometryNode->setCore(TorusGeometry);
//Torus Transformation Node
TransformRefPtr TheTorusNodeTransform = Transform::create();
NodeRefPtr TheTorusTransfromNode = Node::create();
TheTorusTransfromNode->setCore(TheTorusNodeTransform);
TheTorusTransfromNode->addChild(TorusGeometryNode);
setName(TheTorusTransfromNode,"Torus Transform Node");
// Make Main Scene Node and add the Torus
NodeRefPtr scene = Node::create();
scene->setCore(Group::create());
scene->addChild(TheTorusTransfromNode);
setName(scene,"Scene Node");
//Light Beacon Node
TransformRefPtr TheLightBeaconNodeTransform = Transform::create();
NodeRefPtr TheLightBeaconNode = Node::create();
TheLightBeaconNode->setCore(TheLightBeaconNodeTransform);
setName(TheLightBeaconNode,"Light Beacon Node");
//Light Node
DirectionalLightRefPtr TheLightCore = DirectionalLight::create();
TheLightCore->setDirection(Vec3f(1.0,0.0,0.0));
TheLightCore->setAmbient(Color4f(1.0,1.0,1.0,1.0));
TheLightCore->setDiffuse(Color4f(1.0,1.0,1.0,1.0));
TheLightCore->setSpecular(Color4f(1.0,1.0,1.0,1.0));
TheLightCore->setBeacon(TheLightBeaconNode);
NodeRefPtr TheLightNode = Node::create();
TheLightNode->setCore(TheLightCore);
TheLightNode->addChild(scene);
setName(TheLightNode,"Light Node");
NodeRefPtr RootNode = Node::create();
RootNode->setCore(Group::create());
RootNode->addChild(TheLightNode);
RootNode->addChild(TheLightBeaconNode);
setName(RootNode,"Root Node");
// Create the Graphics
GraphicsRefPtr TutorialGraphics = Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
//Create the Main interface
LuaDebuggerInterface TheLuaDebuggerInterface;
// Create The Main InternalWindow
// Create Background to be used with the Main InternalWindow
ColorLayerRefPtr MainInternalWindowBackground = ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
BorderLayoutRefPtr MainInternalWindowLayout = BorderLayout::create();
//Split Panel
BorderLayoutConstraintsRefPtr SplitPanelConstraints = BorderLayoutConstraints::create();
SplitPanelConstraints->setRegion(BorderLayoutConstraints::BORDER_CENTER);
TheLuaDebuggerInterface.getMainSplitPanel()->setConstraints(SplitPanelConstraints);
BorderLayoutConstraintsRefPtr ButtonPanelConstraints = BorderLayoutConstraints::create();
ButtonPanelConstraints->setRegion(BorderLayoutConstraints::BORDER_NORTH);
TheLuaDebuggerInterface.getButtonPanel()->setConstraints(ButtonPanelConstraints);
BorderLayoutConstraintsRefPtr CodeAreaInfoPanelConstraints = BorderLayoutConstraints::create();
CodeAreaInfoPanelConstraints->setRegion(BorderLayoutConstraints::BORDER_SOUTH);
TheLuaDebuggerInterface.getCodeAreaInfoPanel()->setConstraints(CodeAreaInfoPanelConstraints);
InternalWindowRefPtr MainInternalWindow = InternalWindow::create();
MainInternalWindow->pushToChildren(TheLuaDebuggerInterface.getButtonPanel());
MainInternalWindow->pushToChildren(TheLuaDebuggerInterface.getMainSplitPanel());
MainInternalWindow->pushToChildren(TheLuaDebuggerInterface.getCodeAreaInfoPanel());
MainInternalWindow->setLayout(MainInternalWindowLayout);
MainInternalWindow->setBackgrounds(MainInternalWindowBackground);
MainInternalWindow->setTitle("Lua Debugger");
setName(MainInternalWindow,"Internal Window");
// Create the Drawing Surface
UIDrawingSurfaceRefPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRefPtr TutorialUIForeground = UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
//Scene Background
GradientBackgroundRefPtr SceneBackground = GradientBackground::create();
SceneBackground->addLine(Color3f(0.0,0.0,0.0),0.0);
setName(SceneBackground,"Scene Background");
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
sceneManager.setRoot(RootNode);
//sceneManager.setHeadlight(false);
// Add the UI Foreground Object to the Scene
ViewportRefPtr TutorialViewport = sceneManager.getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
TutorialViewport->setBackground(SceneBackground);
TutorialWindow->connectKeyTyped(boost::bind(keyTyped,
_1,
&TheLuaDebuggerInterface));
// 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,
"03LuaDebugger");
MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setPreferredSize(WinSize * 0.85);
//Enter main Loop
TutorialWindow->mainLoop();
TheLuaManager->uninit();
}
osgExit();
return 0;
}
// Initialize OpenSG and set up the scene
int main(int argc, char **argv)
{
//Set the number of aspects
ThreadManager::setNumAspects(2);
ChangeList::setReadWriteDefault(true);
// OSG init
osgInit(argc,argv);
{
// Set up Window
TutorialWindow = createNativeWindow();
TutorialWindow->setUseCallbackForDraw(true);
TutorialWindow->setUseCallbackForReshape(true);
//Initialize Window
TutorialWindow->initWindow();
// Create the SimpleSceneManager helper
SimpleSceneManager sceneManager;
TutorialWindow->setDisplayCallback(boost::bind(display, &sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, &sceneManager));
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
//Attach to events
TutorialWindow->connectMousePressed(boost::bind(mousePressed, _1, &sceneManager));
TutorialWindow->connectMouseReleased(boost::bind(mouseReleased, _1, &sceneManager));
TutorialWindow->connectMouseMoved(boost::bind(mouseMoved, _1, &sceneManager));
TutorialWindow->connectMouseDragged(boost::bind(mouseDragged, _1, &sceneManager));
//Torus Material
MaterialRecPtr TheTorusMaterial = SimpleMaterial::create();
dynamic_pointer_cast<SimpleMaterial>(TheTorusMaterial)->setAmbient(Color3f(0.2,0.2,0.2));
dynamic_pointer_cast<SimpleMaterial>(TheTorusMaterial)->setDiffuse(Color3f(0.7,0.7,0.7));
dynamic_pointer_cast<SimpleMaterial>(TheTorusMaterial)->setSpecular(Color3f(0.7,0.7,0.7));
dynamic_pointer_cast<SimpleMaterial>(TheTorusMaterial)->setShininess(100.0f);
//Torus Geometry
GeometryRecPtr TorusGeometry = makeTorusGeo(.5, 2, 32, 32);
TorusGeometry->setMaterial(TheTorusMaterial);
NodeRecPtr TorusGeometryNode = Node::create();
TorusGeometryNode->setCore(TorusGeometry);
//Make Torus Node
NodeRecPtr TorusNode = Node::create();
TransformRecPtr TorusNodeTrans = Transform::create();
setName(TorusNodeTrans, std::string("TorusNodeTransformationCore"));
TorusNode->setCore(TorusNodeTrans);
TorusNode->addChild(TorusGeometryNode);
//Make Main Scene Node
NodeRecPtr scene = Node::create();
ComponentTransformRecPtr Trans = ComponentTransform::create();
setName(Trans, std::string("MainTransformationCore"));
scene->setCore(Trans);
scene->addChild(TorusNode);
AnimationRecPtr TheAnimation = setupAnimation(TorusNodeTrans, TutorialWindow);
TutorialWindow->connectKeyPressed(boost::bind(keyPressed, _1, TheAnimation.get(), TutorialWindow.get()));
TheAnimation->connectAnimationStarted(boost::bind(animationStarted, _1));
TheAnimation->connectAnimationStopped(boost::bind(animationStopped, _1));
TheAnimation->connectAnimationPaused(boost::bind(animationPaused, _1));
TheAnimation->connectAnimationUnpaused(boost::bind(animationUnpaused, _1));
TheAnimation->connectAnimationEnded(boost::bind(animationEnded, _1));
TheAnimation->connectAnimationCycled(boost::bind(animationCycled, _1));
commitChanges();
// tell the manager what to manage
sceneManager.setRoot (scene);
// show the whole scene
sceneManager.showAll();
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"OpenSG 01Animation Window");
// store a pointer to the application thread
ApplicationThread = dynamic_cast<OSG::Thread *>(OSG::ThreadManager::getAppThread());
//create the thread that will run generation of new matrices
RenderThread =
OSG::dynamic_pointer_cast<OSG::Thread>(
OSG::ThreadManager::the()->getThread("render", true));
//Start the render thread on aspect 1
RenderThread->runFunction(draw, 1, static_cast<void *>(&sceneManager));
//Enter main Loop
TutorialWindow->mainLoop();
//Stop the render thread
RenderThread->terminate();
}
osgExit();
return 0;
}
// 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;
}
// Initialize GLUT & OpenSG and set up the scene
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
{
// Set up Window
WindowEventProducerRecPtr TutorialWindow = createNativeWindow();
//Initialize Window
TutorialWindow->initWindow();
SimpleSceneManager sceneManager;
TutorialWindow->setDisplayCallback(boost::bind(display, &sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, &sceneManager));
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
//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));
//Torus Material
SimpleMaterialUnrecPtr TheTorusMaterial = SimpleMaterial::create();
TheTorusMaterial->setAmbient(Color3f(0.3,0.3,0.3));
TheTorusMaterial->setDiffuse(Color3f(0.7,0.7,0.7));
TheTorusMaterial->setSpecular(Color3f(1.0,1.0,1.0));
TheTorusMaterial->setShininess(20.0);
//Torus Geometry
GeometryUnrecPtr TorusGeometry = makeTorusGeo(.5, 2, 32, 32);
TorusGeometry->setMaterial(TheTorusMaterial);
NodeUnrecPtr TorusGeometryNode = Node::create();
TorusGeometryNode->setCore(TorusGeometry);
//Make Torus Node
NodeUnrecPtr TorusNode = Node::create();
TransformUnrecPtr TorusNodeTrans = Transform::create();
setName(TorusNodeTrans, std::string("TorusNodeTransformationCore"));
TorusNode->setCore(TorusNodeTrans);
TorusNode->addChild(TorusGeometryNode);
//Make Main Scene Node
NodeUnrecPtr scene = Node::create();
ComponentTransformUnrecPtr Trans = ComponentTransform::create();
setName(Trans, std::string("MainTransformationCore"));
scene->setCore(Trans);
// add the torus as a child
scene->addChild(TorusNode);
AnimationGroupUnrecPtr TheAnimation = setupAnimation(TheTorusMaterial, TorusNodeTrans);
TutorialWindow->connectKeyPressed(boost::bind(keyPressed, _1,
TheAnimation.get(),
TutorialWindow.get()));
TheAnimation->attachUpdateProducer(TutorialWindow);
TheAnimation->start();
// tell the manager what to manage
sceneManager.setRoot (scene);
//Create the Documentation
SimpleScreenDoc TheSimpleScreenDoc(&sceneManager, TutorialWindow);
// show the whole scene
sceneManager.showAll();
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"07AnimationGroup");
//Enter main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
// Initialize GLUT & OpenSG and set up the scene
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
{
// Set up Window
TutorialWindow = createNativeWindow();
TutorialWindow->setDisplayCallback(display);
TutorialWindow->setReshapeCallback(reshape);
//Add Window Listener
TutorialKeyListener TheKeyListener;
TutorialWindow->addKeyListener(&TheKeyListener);
TutorialMouseListener TheTutorialMouseListener;
TutorialMouseMotionListener TheTutorialMouseMotionListener;
TutorialWindow->addMouseListener(&TheTutorialMouseListener);
TutorialWindow->addMouseMotionListener(&TheTutorialMouseMotionListener);
//Initialize Window
TutorialWindow->initWindow();
//Torus Material
TheTorusMaterial = SimpleMaterial::create();
dynamic_pointer_cast<SimpleMaterial>(TheTorusMaterial)->setAmbient(Color3f(0.2,0.2,0.2));
dynamic_pointer_cast<SimpleMaterial>(TheTorusMaterial)->setDiffuse(Color3f(0.7,0.7,0.7));
dynamic_pointer_cast<SimpleMaterial>(TheTorusMaterial)->setSpecular(Color3f(0.7,0.7,0.7));
dynamic_pointer_cast<SimpleMaterial>(TheTorusMaterial)->setShininess(100.0f);
//Torus Geometry
GeometryRefPtr TorusGeometry = makeTorusGeo(.5, 2, 32, 32);
TorusGeometry->setMaterial(TheTorusMaterial);
NodeRefPtr TorusGeometryNode = Node::create();
TorusGeometryNode->setCore(TorusGeometry);
//Make Torus Node
NodeRefPtr TorusNode = Node::create();
TorusNodeTrans = Transform::create();
setName(TorusNodeTrans, std::string("TorusNodeTransformationCore"));
TorusNode->setCore(TorusNodeTrans);
TorusNode->addChild(TorusGeometryNode);
//Make Main Scene Node
NodeRefPtr scene = Node::create();
Trans = ComponentTransform::create();
setName(Trans, std::string("MainTransformationCore"));
scene->setCore(Trans);
scene->addChild(TorusNode);
setupAnimation();
commitChanges();
// Create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// Tell the Manager what to manage
mgr->setWindow(TutorialWindow);
// tell the manager what to manage
mgr->setRoot (scene);
// show the whole scene
mgr->showAll();
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"OpenSG 02TransformAnimation Window");
//Enter main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
{
// Set up Window
WindowEventProducerRecPtr TutorialWindow = createNativeWindow();
//Initialize Window
TutorialWindow->initWindow();
SimpleSceneManager sceneManager;
TutorialWindow->setDisplayCallback(boost::bind(display, &sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, &sceneManager));
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
//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));
TutorialWindow->connectKeyPressed(boost::bind(keyPressed, _1, TutorialWindow.get()));
//Shader Chunk
SimpleSHLChunkUnrecPtr TheSHLChunk = SimpleSHLChunk::create();
TheSHLChunk->setVertexProgram(createSHLVertexProg());
TheSHLChunk->setFragmentProgram(createSHLFragProg());
//TheSHLChunk->addUniformVariable("Color1",Vec4f(0.0f,1.0f,0.0f,1.0f));
//TheSHLChunk->addUniformVariable("Color2",Vec4f(1.0f,1.0f,1.0f,1.0f));
//Shader Parameter Chunk
SimpleSHLVariableChunkUnrecPtr SHLParameters = SimpleSHLVariableChunk::create();
//Color Parameter
SHLParameters->addUniformVariable("Color1",Vec4f(0.0f,1.0f,0.0f,1.0f));
SHLParameters->addUniformVariable("Color2",Vec4f(1.0f,1.0f,1.0f,1.0f));
ChunkMaterialUnrecPtr ShaderMaterial = ChunkMaterial::create();
ShaderMaterial->addChunk(TheSHLChunk);
ShaderMaterial->addChunk(SHLParameters);
//Torus Node
GeometryUnrecPtr TorusGeometry = makeTorusGeo(5.0f,20.0f, 32,32);
TorusGeometry->setMaterial(ShaderMaterial);
NodeUnrecPtr TorusNode = Node::create();
TorusNode->setCore(TorusGeometry);
// Make Main Scene Node
NodeUnrecPtr scene = Node::create();
scene->setCore(Group::create());
scene->addChild(TorusNode);
sceneManager.setRoot(scene);
// Show the whole Scene
sceneManager.showAll();
//Create the Animations
ShaderVariableVec4fUnrecPtr Color1Parameter;
ShaderVariableVec4fUnrecPtr Color2Parameter;
Color1Parameter = dynamic_cast<ShaderVariableVec4f*>(const_cast<ShaderVariable*>(SHLParameters->getVariables()->getVariable("Color1")));
Color2Parameter = dynamic_cast<ShaderVariableVec4f*>(const_cast<ShaderVariable*>(SHLParameters->getVariables()->getVariable("Color2")));
commitChanges();
AnimationUnrecPtr TheAnimation = setupAnimation(Color1Parameter, "value");
TheAnimation->attachUpdateProducer(TutorialWindow);
TheAnimation->start();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"04ShaderAnimation");
//Main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
// Initialize GLUT & OpenSG and set up the scene
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
// 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
// this time, create just the core of the geometry
GeometryPtr torus = makeTorusGeo( .5, 2, 8, 12 );
// create the scene
// the scene has a single group with ncopies transformations below,
// each of these carries a Node that shares the geometry
/*
The Switch NodeCore very similar to the Group, but it has the additional
capability to only show one or none of its children.
This is controlled by the choice Field, and is used below in the keys
function.
*/
// create the root Switch node
NodePtr scene = Node::create();
sw = Switch::create();
beginEditCP(sw, Switch::ChoiceFieldMask);
sw->setChoice(-2); // Note: this will be Switch::ALL in 1.2
endEditCP(sw, Switch::ChoiceFieldMask);
beginEditCP(scene, Node::CoreFieldMask | Node::ChildrenFieldMask);
scene->setCore(sw);
// create the copied geometry nodes and their transformations
for(UInt16 i = 0; i<ncopies; ++i)
{
// create the nodes for the shared Geometry core
NodePtr geonode = Node::create();
// assign the Core to the Node
beginEditCP(geonode, Node::CoreFieldMask );
{
geonode->setCore(torus);
}
endEditCP (geonode, Node::CoreFieldMask );
// add a transformation for every Geometry
NodePtr transnode = Node::create();
trans[i] = Transform::create();
beginEditCP(transnode, Node::CoreFieldMask | Node::ChildrenFieldMask);
{
transnode->setCore (trans[i]);
transnode->addChild(geonode );
}
endEditCP (transnode, Node::CoreFieldMask | Node::ChildrenFieldMask);
scene->addChild(transnode);
}
endEditCP (scene, Node::CoreFieldMask | Node::ChildrenFieldMask);
// create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// tell the manager what to manage
mgr->setWindow(gwin );
mgr->setRoot (scene);
// show the whole scene
mgr->showAll();
// GLUT main loop
glutMainLoop();
return 0;
}
// Initialize GLUT & OpenSG and set up the scene
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
// GLUT init
int winid = setupGLUT(&argc, argv);
// the connection between GLUT and OpenSG
GLUTWindowPtr gwin= GLUTWindow::create();
gwin->setId(winid);
gwin->setSize( 800, 800 );
gwin->init();
// Create the shader material
ChunkMaterialPtr cmat = ChunkMaterial::create();
SHLChunkPtr shl = SHLChunk::create();
beginEditCP(shl);
shl->setProgramParameter(GL_GEOMETRY_INPUT_TYPE_EXT, GL_TRIANGLES_ADJACENCY_EXT);
shl->setProgramParameter(GL_GEOMETRY_OUTPUT_TYPE_EXT, GL_TRIANGLES);
// ok we create a maximum of 6 vertices.
shl->setProgramParameter(GL_GEOMETRY_VERTICES_OUT_EXT, 6);
shl->setVertexProgram(_vertex_shader);
shl->setFragmentProgram(_fragment_shader);
shl->setGeometryProgram(_geometry_shader);
endEditCP(shl);
beginEditCP(cmat);
cmat->addChunk(shl);
endEditCP(cmat);
// create root node
_scene = Node::create();
// create torus
GeometryPtr geo = makeTorusGeo(.8, 1.8, 32, 32);
beginEditCP( geo, Geometry::MaterialFieldMask);
geo->setMaterial(cmat);
endEditCP(geo, Geometry::MaterialFieldMask);
NodePtr torus = Node::create();
beginEditCP(torus, Node::CoreFieldMask);
torus->setCore(geo);
endEditCP(torus, Node::CoreFieldMask);
// add torus to scene
GroupPtr group = Group::create();
beginEditCP(_scene);
_scene->setCore(group);
_scene->addChild(torus);
endEditCP(_scene);
// create the SimpleSceneManager helper
_mgr = new SimpleSceneManager;
// tell the manager what to manage
_mgr->setWindow(gwin );
_mgr->setRoot(_scene);
// show the whole scene
_mgr->showAll();
// GLUT main loop
glutMainLoop();
return 0;
}
// Initialize GLUT & OpenSG and set up the scene
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
// Set up Window
TutorialWindowEventProducer = createDefaultWindowEventProducer();
WindowPtr MainWindow = TutorialWindowEventProducer->initWindow();
TutorialWindowEventProducer->setDisplayCallback(display);
TutorialWindowEventProducer->setReshapeCallback(reshape);
//Add Window Listener
TutorialKeyListener TheKeyListener;
TutorialWindowEventProducer->addKeyListener(&TheKeyListener);
TutorialMouseListener TheTutorialMouseListener;
TutorialMouseMotionListener TheTutorialMouseMotionListener;
TutorialWindowEventProducer->addMouseListener(&TheTutorialMouseListener);
TutorialWindowEventProducer->addMouseMotionListener(&TheTutorialMouseMotionListener);
TutorialUpdateListener TheTutorialUpdateListener;
TutorialWindowEventProducer->addUpdateListener(&TheTutorialUpdateListener);
// Create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// Tell the Manager what to manage
mgr->setWindow(TutorialWindowEventProducer->getWindow());
////////////////
// Create the Graphics
GraphicsPtr TutorialGraphics = osg::Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
/******************************************************
Create an Button Component and
a simple Font.
See 17Label_Font for more
information about Fonts.
******************************************************/
ButtonPtr ExampleButton = osg::Button::create();
UIFontPtr ExampleFont = osg::UIFont::create();
beginEditCP(ExampleButton, Button::MinSizeFieldMask | Button::MaxSizeFieldMask | Button::PreferredSizeFieldMask | Button::ToolTipTextFieldMask | Button::TextFieldMask |
Button::FontFieldMask | Button::TextColorFieldMask | Button::RolloverTextColorFieldMask | Button::ActiveTextColorFieldMask | Button::AlignmentFieldMask);
ExampleButton->setMinSize(Vec2f(50, 25));
ExampleButton->setMaxSize(Vec2f(200, 100));
ExampleButton->setPreferredSize(Vec2f(100, 50));
ExampleButton->setToolTipText("Click to start/pause");
ExampleButton->setText("start/pause");
ExampleButton->setFont(ExampleFont);
ExampleButton->setTextColor(Color4f(1.0, 0.0, 0.0, 1.0));
ExampleButton->setRolloverTextColor(Color4f(1.0, 0.0, 1.0, 1.0));
ExampleButton->setActiveTextColor(Color4f(1.0, 0.0, 0.0, 1.0));
ExampleButton->setAlignment(Vec2f(.5,0.5));
endEditCP(ExampleButton, Button::MinSizeFieldMask | Button::MaxSizeFieldMask | Button::PreferredSizeFieldMask | Button::ToolTipTextFieldMask | Button::TextFieldMask |
Button::FontFieldMask | Button::TextColorFieldMask | Button::RolloverTextColorFieldMask | Button::ActiveTextColorFieldMask | Button::AlignmentFieldMask);
// Create an ActionListener and assign it to ExampleButton
// This Class is defined above, and will cause the output
// window to display "Button 1 Action" when pressed
ExampleButtonActionListener TheExampleButtonActionListener;
ExampleButton->addActionListener(&TheExampleButtonActionListener);
//////////////////
//Torus Material
TheTorusMaterial = SimpleMaterial::create();
beginEditCP(TheTorusMaterial);
SimpleMaterialPtr::dcast(TheTorusMaterial)->setAmbient(Color3f(0.3,0.3,0.3));
SimpleMaterialPtr::dcast(TheTorusMaterial)->setDiffuse(Color3f(0.7,0.7,0.7));
SimpleMaterialPtr::dcast(TheTorusMaterial)->setSpecular(Color3f(1.0,1.0,1.0));
endEditCP(TheTorusMaterial);
//Torus Geometry
GeometryPtr TorusGeometry = makeTorusGeo(.5, 2, 32, 32);
beginEditCP(TorusGeometry);
TorusGeometry->setMaterial(TheTorusMaterial);
endEditCP (TorusGeometry);
NodePtr TorusGeometryNode = Node::create();
beginEditCP(TorusGeometryNode, Node::CoreFieldMask);
TorusGeometryNode->setCore(TorusGeometry);
endEditCP (TorusGeometryNode, Node::CoreFieldMask);
//Make Torus Node
NodePtr TorusNode = Node::create();
TransformPtr TorusNodeTrans;
TorusNodeTrans = Transform::create();
setName(TorusNodeTrans, std::string("TorusNodeTransformationCore"));
beginEditCP(TorusNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
TorusNode->setCore(TorusNodeTrans);
TorusNode->addChild(TorusGeometryNode);
endEditCP (TorusNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
//Make Main Scene Node
NodePtr scene = Node::create();
ComponentTransformPtr Trans;
Trans = ComponentTransform::create();
setName(Trans, std::string("MainTransformationCore"));
beginEditCP(scene, Node::CoreFieldMask | Node::ChildrenFieldMask);
{
scene->setCore(Trans);
// add the torus as a child
scene->addChild(TorusNode);
}
endEditCP (scene, Node::CoreFieldMask | Node::ChildrenFieldMask);
setupAnimation();
// Create Background to be used with the Main InternalWindow
ColorLayerPtr MainInternalWindowBackground = osg::ColorLayer::create();
beginEditCP(MainInternalWindowBackground, ColorLayer::ColorFieldMask);
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
endEditCP(MainInternalWindowBackground, ColorLayer::ColorFieldMask);
InternalWindowPtr MainInternalWindow = osg::InternalWindow::create();
LayoutPtr MainInternalWindowLayout = osg::FlowLayout::create();
beginEditCP(MainInternalWindow, InternalWindow::ChildrenFieldMask | InternalWindow::LayoutFieldMask | InternalWindow::BackgroundsFieldMask | InternalWindow::AlignmentInDrawingSurfaceFieldMask | InternalWindow::ScalingInDrawingSurfaceFieldMask | InternalWindow::DrawTitlebarFieldMask | InternalWindow::ResizableFieldMask);
MainInternalWindow->getChildren().push_back(ExampleButton);
MainInternalWindow->setLayout(MainInternalWindowLayout);
MainInternalWindow->setBackgrounds(MainInternalWindowBackground);
MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setScalingInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setDrawTitlebar(false);
MainInternalWindow->setResizable(false);
endEditCP(MainInternalWindow, InternalWindow::ChildrenFieldMask | InternalWindow::LayoutFieldMask | InternalWindow::BackgroundsFieldMask | InternalWindow::AlignmentInDrawingSurfaceFieldMask | InternalWindow::ScalingInDrawingSurfaceFieldMask | InternalWindow::DrawTitlebarFieldMask | InternalWindow::ResizableFieldMask);
// Create the Drawing Surface
UIDrawingSurfacePtr TutorialDrawingSurface = UIDrawingSurface::create();
beginEditCP(TutorialDrawingSurface, UIDrawingSurface::GraphicsFieldMask | UIDrawingSurface::EventProducerFieldMask);
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindowEventProducer);
endEditCP(TutorialDrawingSurface, UIDrawingSurface::GraphicsFieldMask | UIDrawingSurface::EventProducerFieldMask);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundPtr TutorialUIForeground = osg::UIForeground::create();
beginEditCP(TutorialUIForeground, UIForeground::DrawingSurfaceFieldMask);
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
endEditCP(TutorialUIForeground, UIForeground::DrawingSurfaceFieldMask);
mgr->setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportPtr TutorialViewport = mgr->getWindow()->getPort(0);
beginEditCP(TutorialViewport, Viewport::ForegroundsFieldMask);
TutorialViewport->getForegrounds().push_back(TutorialUIForeground);
beginEditCP(TutorialViewport, Viewport::ForegroundsFieldMask);
// show the whole scene
mgr->showAll();
TheAnimationAdvancer->start();
Vec2f WinSize(TutorialWindowEventProducer->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindowEventProducer->getDesktopSize() - WinSize) *0.5);
TutorialWindowEventProducer->openWindow(WinPos,
WinSize,
"24AnimationAction");
//Enter main Loop
TutorialWindowEventProducer->mainLoop();
osgExit();
return 0;
}
// Initialize GLUT & OpenSG and set up the scene
int main(int argc, char **argv)
{
printf("Usage: testCGShader [base texture filename] [normal map filename]\n");
char *base_img_name = "wood.jpg";
char *normal_map_img_name = "normalmap.jpg";
Color4f tmp;
if( argc > 1 )
base_img_name = argv[1];
if( argc > 2 )
normal_map_img_name = argv[2];
// OSG init
osgInit(argc,argv);
// GLUT init
int winid = setupGLUT(&argc, argv);
// the connection between GLUT and OpenSG
GLUTWindowPtr gwin= GLUTWindow::create();
gwin->setId(winid);
gwin->setSize( 800, 800 );
gwin->init();
// Create the shader material
// Read the image for the base texture
ImagePtr base_img = Image::create();
if(!base_img->read(base_img_name))
{
fprintf(stderr, "Couldn't read base texture '%s'!\n", base_img_name);
return 1;
}
ImagePtr normal_map_img = Image::create();
if(!normal_map_img->read(normal_map_img_name))
{
fprintf(stderr, "Couldn't read normalmap texture '%s'!\n", normal_map_img_name);
return 1;
}
ChunkMaterialPtr cmat = ChunkMaterial::create();
MaterialChunkPtr matc = MaterialChunk::create();
beginEditCP(matc);
matc->setAmbient(Color4f(0.1, 0.1, 0.1, 1.0));
matc->setDiffuse(Color4f(0.3, 0.3, 0.3, 1.0));
matc->setSpecular(Color4f(0.8, 0.8, 0.8, 1.0));
matc->setShininess(100);
matc->setLit(true);
endEditCP(matc);
// we use the glstate in the cg program so we force
// to use the CG_PROFILE_ARBVP1 and CG_PROFILE_ARBFP1 extensions.
CGChunkPtr cg = CGChunk::create();
beginEditCP(cg);
cg->setVertexProfile(CG_PROFILE_ARBVP1);
cg->setVertexProgram(_vp_program);
cg->setFragmentProfile(CG_PROFILE_ARBFP1);
cg->setFragmentProgram(_fp_program);
// some optional parameters.
//cg->setVertexEntryPoint("main");
//cg->getVertexArguments().push_back("...");
//cg->setFragmentEntryPoint("main");
//cg->getFragmentArguments().push_back("...");
endEditCP(cg);
TextureChunkPtr tex_base = TextureChunk::create();
beginEditCP(tex_base);
tex_base->setImage(base_img);
tex_base->setMinFilter(GL_LINEAR_MIPMAP_LINEAR);
tex_base->setMagFilter(GL_LINEAR);
tex_base->setWrapS(GL_REPEAT);
tex_base->setWrapT(GL_REPEAT);
tex_base->setEnvMode(GL_MODULATE);
endEditCP(tex_base);
TextureChunkPtr tex_normal_map = TextureChunk::create();
beginEditCP(tex_normal_map);
tex_normal_map->setImage(normal_map_img);
tex_normal_map->setMinFilter(GL_LINEAR_MIPMAP_LINEAR);
tex_normal_map->setMagFilter(GL_LINEAR);
tex_normal_map->setWrapS(GL_REPEAT);
tex_normal_map->setWrapT(GL_REPEAT);
tex_normal_map->setEnvMode(GL_MODULATE);
endEditCP(tex_normal_map);
beginEditCP(cmat);
cmat->addChunk(matc);
cmat->addChunk(cg);
cmat->addChunk(tex_base);
cmat->addChunk(tex_normal_map);
endEditCP(cmat);
// create root node
_scene = Node::create();
// create torus
GeometryPtr geo = makeTorusGeo(.8, 1.8, 128, 128);
beginEditCP( geo, Geometry::MaterialFieldMask);
geo->setMaterial(cmat);
endEditCP(geo, Geometry::MaterialFieldMask);
NodePtr torus = Node::create();
beginEditCP(torus, Node::CoreFieldMask);
torus->setCore(geo);
endEditCP(torus, Node::CoreFieldMask);
// add torus to scene
GroupPtr group = Group::create();
beginEditCP(_scene);
_scene->setCore(group);
_scene->addChild(torus);
endEditCP(_scene);
// create the SimpleSceneManager helper
_mgr = new SimpleSceneManager;
// tell the manager what to manage
_mgr->setWindow(gwin );
_mgr->setRoot(_scene);
// show the whole scene
_mgr->showAll();
// GLUT main loop
glutMainLoop();
return 0;
}
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;
}
// Initialize OpenSG and set up the scene
int main(int argc, char **argv)
{
//Print key command info
std::cout << "\n\nKEY COMMANDS:" << std::endl;
std::cout << "space Play/Pause the animation" << std::endl;
std::cout << "CTRL-Q Exit\n\n" << std::endl;
// OSG init
osgInit(argc,argv);
// Set up Window
TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
TutorialWindow->setDisplayCallback(display);
TutorialWindow->setReshapeCallback(reshape);
//Add Window Listener
TutorialKeyListener TheKeyListener;
TutorialWindow->addKeyListener(&TheKeyListener);
TutorialMouseListener TheTutorialMouseListener;
TutorialMouseMotionListener TheTutorialMouseMotionListener;
TutorialWindow->addMouseListener(&TheTutorialMouseListener);
TutorialWindow->addMouseMotionListener(&TheTutorialMouseMotionListener);
// Create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// Tell the Manager what to manage
mgr->setWindow(TutorialWindow);
//Torus Geometry
TorusGeometry = makeTorusGeo(.5, 2, 16, 16);
NodeUnrecPtr TorusGeometryNode = Node::create();
TorusGeometryNode->setCore(TorusGeometry);
//Make Torus Node
NodeUnrecPtr TorusNode = Node::create();
TransformUnrecPtr TorusNodeTrans;
TorusNodeTrans = Transform::create();
setName(TorusNodeTrans, std::string("TorusNodeTransformationCore"));
TorusNode->setCore(TorusNodeTrans);
TorusNode->addChild(TorusGeometryNode);
//Make Main Scene Node
NodeUnrecPtr scene = Node::create();
//ComponentTransformUnrecPtr Trans;
//Trans = ComponentTransform::create();
//setName(Trans, std::string("MainTransformationCore"));
scene->setCore(Group::create());
// add the torus as a child
scene->addChild(TorusNode);
setupAnimation();
mgr->setRoot (scene);
// show the whole scene
mgr->showAll();
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"15LoadXMLAnimation");
//Enter main Loop
TutorialWindow->mainLoop();
osgExit();
return 0;
}
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));
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
TutorialWindow->connectKeyTyped(boost::bind(keyTyped, _1));
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));
BoostPath EffectFilePath("./Data/goochyPt.cgfx");
if(argc >= 2)
{
EffectFilePath = BoostPath(argv[1]);
if(!boost::filesystem::exists(EffectFilePath))
{
std::cerr << "Could not load file: "<< EffectFilePath.string()
<< ", because no such files exists."<< std::endl;
EffectFilePath = BoostPath("./Data/goochyPt.cgfx");
}
}
//Make the CgFX Material
CgFXMaterialRecPtr ExampleMaterial = CgFXMaterial::create();
ExampleMaterial->setEffectFile(EffectFilePath.string());
// Make Torus Node (creates Torus in background of scene)
GeometryRefPtr TorusGeometry = makeTorusGeo(.5, 2, 16, 16);
//GeometryRefPtr TorusGeometry = makeBoxGeo(1.0,1.0,1.0,1,1,1);
TorusGeometry->setMaterial(ExampleMaterial);
TorusGeometry->setDlistCache(false);
NodeRefPtr TorusGeometryNode = makeNodeFor(TorusGeometry);
// Make Main Scene Node and add the Torus
NodeRefPtr scene = OSG::Node::create();
scene->setCore(OSG::Group::create());
scene->addChild(TorusGeometryNode);
sceneManager.setRoot(scene);
//Create the Documentation Foreground and add it to the viewport
SimpleScreenDoc TheSimpleScreenDoc(&sceneManager, TutorialWindow);
// 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,
"04CgFXMaterial");
commitChanges();
//Enter main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
// Initialize GLUT & OpenSG and set up the scene
int main(int argc, char **argv)
{
printf("Usage: testCGShader <filename.vp> <filename.fp>\n");
if( argc < 3 )
return 0;
// OSG init
osgInit(argc,argv);
// GLUT init
int winid = setupGLUT(&argc, argv);
// the connection between GLUT and OpenSG
GLUTWindowPtr gwin= GLUTWindow::create();
gwin->setId(winid);
gwin->setSize( 800, 800 );
gwin->init();
// Create the shader material
ChunkMaterialPtr cmat = ChunkMaterial::create();
MaterialChunkPtr matc = MaterialChunk::create();
beginEditCP(matc);
matc->setAmbient(Color4f(0.1, 0.1, 0.1, 1.0));
matc->setDiffuse(Color4f(0.3, 0.3, 0.3, 1.0));
matc->setSpecular(Color4f(0.8, 0.8, 0.8, 1.0));
matc->setShininess(100);
matc->setLit(true);
endEditCP(matc);
SHLChunkPtr shl = SHLChunk::create();
beginEditCP(shl);
shl->readVertexProgram(argv[1]);
shl->readFragmentProgram(argv[2]);
endEditCP(shl);
beginEditCP(cmat);
cmat->addChunk(shl);
endEditCP(cmat);
// create root node
_scene = Node::create();
// create torus
GeometryPtr geo = makeTorusGeo(.8, 1.8, 128, 128);
beginEditCP( geo, Geometry::MaterialFieldMask);
geo->setMaterial(cmat);
endEditCP(geo, Geometry::MaterialFieldMask);
NodePtr torus = Node::create();
beginEditCP(torus, Node::CoreFieldMask);
torus->setCore(geo);
endEditCP(torus, Node::CoreFieldMask);
// add torus to scene
GroupPtr group = Group::create();
beginEditCP(_scene);
_scene->setCore(group);
_scene->addChild(torus);
endEditCP(_scene);
// create the SimpleSceneManager helper
_mgr = new SimpleSceneManager;
// tell the manager what to manage
_mgr->setWindow(gwin );
_mgr->setRoot(_scene);
/*
// create point headlight
_mgr->turnHeadlightOff();
NodePtr headlight = _mgr->getHighlight();
PointLightPtr light = PointLight::create();
beginEditCP(light);
light->setAmbient (.3, .3, .3, 1);
light->setDiffuse ( 1, 1, 1, 1);
light->setSpecular ( 1, 1, 1, 1);
light->setBeacon (_mgr->getCamera()->getBeacon());
endEditCP(light);
beginEditCP(_scene);
_scene->setCore(light);
endEditCP(_scene);
*/
// show the whole scene
_mgr->showAll();
// GLUT main loop
glutMainLoop();
return 0;
}
