// 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)); BoostPath FilePath("../Animation/Data/Nanobot.dae"); if(argc >= 2) { FilePath = BoostPath(argv[1]); if(!boost::filesystem::exists(FilePath)) { std::cerr << "Could not load file: "<< FilePath.string() << ", because no such files exists."<< std::endl; FilePath = BoostPath("../Animation/Data/Nanobot.dae"); } } NodeRefPtr LoadedRoot; std::vector<AnimationRecPtr> LoadedAnimations; FCFileType::FCPtrStore ObjStore; try { ObjStore = FCFileHandler::the()->read(FilePath); } catch(std::exception &ex) { std::cerr << "Failed to load file: " << FilePath.string() << ", error:" << ex.what() << std::endl; return -1; } for(FCFileType::FCPtrStore::iterator StorItor(ObjStore.begin()); StorItor != ObjStore.end(); ++StorItor) { //Animations if((*StorItor)->getType().isDerivedFrom(Animation::getClassType())) { LoadedAnimations.push_back(dynamic_pointer_cast<Animation>(*StorItor)); LoadedAnimations.back()->attachUpdateProducer(TutorialWindow); LoadedAnimations.back()->start(); } //Root Node if((*StorItor)->getType() == Node::getClassType() && dynamic_pointer_cast<Node>(*StorItor)->getParent() == NULL) { LoadedRoot = dynamic_pointer_cast<Node>(*StorItor); } } if(LoadedRoot == NULL) { LoadedRoot = SceneFileHandler::the()->read(FilePath.string().c_str()); } if(LoadedRoot == NULL) { LoadedRoot= makeTorus(.5, 2, 32, 32); } //Make the fog node PostShaderStageRecPtr PostShaderStageCore = PostShaderStage::create(); PostShaderStageCore->clearPasses(); PostShaderStageCore->addPass("", generateNoEffectProg()); DirectionalLightRecPtr SceneLightCore = DirectionalLight::create(); SceneLightCore->setAmbient(Color4f(0.2f, 0.2f, 0.2f, 1.0f)); SceneLightCore->setDiffuse(Color4f(0.8f, 0.8f, 0.8f, 1.0f)); SceneLightCore->setSpecular(Color4f(1.0f, 1.0f, 1.0f, 1.0f)); NodeRefPtr SceneLight = makeNodeFor(SceneLightCore); SceneLight->addChild(LoadedRoot); NodeRefPtr PostShaderStageNode = makeNodeFor(PostShaderStageCore); PostShaderStageNode->addChild(SceneLight); //Make Main Scene Node NodeRefPtr scene = makeCoredNode<Group>(); scene->addChild(PostShaderStageNode); // tell the manager what to manage sceneManager.setRoot (scene); SceneLightCore->setBeacon(sceneManager.getCamera()->getBeacon()); //Create the Documentation Foreground and add it to the viewport SimpleScreenDoc TheSimpleScreenDoc(&sceneManager, TutorialWindow); // show the whole scene sceneManager.showAll(); sceneManager.getWindow()->getPort(0)->setTravMask(1); RenderOptionsRecPtr ViewportRenderOptions = RenderOptions::create(); ViewportRenderOptions->setRenderProperties(0x0); ViewportRenderOptions->setRenderProperties(RenderPropertiesPool::the()->getFrom1("Default")); ViewportRenderOptions->setRenderProperties(0x01); sceneManager.getWindow()->getPort(0)->setRenderOptions(ViewportRenderOptions); Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f); Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5); TutorialWindow->openWindow(WinPos, WinSize, "Collada Loader"); TutorialWindow->connectKeyPressed(boost::bind(keyPressed, _1, TutorialWindow.get(), PostShaderStageCore.get())); //Enter main Loop TutorialWindow->mainLoop(); } osgExit(); return 0; }
// Initialize GLUT & OpenSG and set up the rootNode int main(int argc, char **argv) { // OSG init osgInit(argc,argv); { // Set up Window WindowEventProducerRecPtr TutorialWindow = createNativeWindow(); TutorialWindow->initWindow(); 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->connectMouseMoved(boost::bind(mouseMoved, _1, &sceneManager)); TutorialWindow->connectMouseDragged(boost::bind(mouseDragged, _1, &sceneManager)); TutorialWindow->connectKeyPressed(boost::bind(keyPressed,_1)); // Tell the Manager what to manage sceneManager.setWindow(TutorialWindow); UInt32 SceneMask(1), PathMask(4); BoostPath SceneFilePath(".//Data//CellParts.osb"); if(argc >= 2) { SceneFilePath = BoostPath(argv[1]); if(!boost::filesystem::exists(SceneFilePath)) { SceneFilePath = BoostPath(".//Data//CellParts.osb"); } } //Make Base Geometry Node NodeRecPtr SceneGeometryNode = SceneFileHandler::the()->read(SceneFilePath.string().c_str()); SceneGeometryNode->setTravMask(SceneMask); if(SceneGeometryNode == NULL) { SceneGeometryNode = makeTorus(1.0, 10.0, 24, 24); } //Construct the Root Node NodeRecPtr RootNode = makeCoredNode<Group>(); RootNode->addChild(SceneGeometryNode); commitChanges(); //Create the Octree SLOG << "Started Building Octree" << std::endl; SLOG << "This may take some time ..." << std::endl; Time StartTime; StartTime = getSystemTime(); OctreePtr TheOctree = Octree::buildTree(RootNode,SceneMask,6,1.5,true); SLOG << "Building Octree: " << getSystemTime() - StartTime << " s" << std::endl; Pnt3f Min,Max; TheOctree->getRoot()->getVolume(); SLOG << "Octree: "<< std::endl << " Depth: " << TheOctree->getDepth() << std::endl << " Bounds: " << TheOctree->getRoot()->getVolume().getMin() << " : " << TheOctree->getRoot()->getVolume().getMax() << std::endl << " NodeCount: " << TheOctree->getNodeCount() << std::endl << " LeafNodeCount: " << TheOctree->getLeafNodeCount() << std::endl << " BranchNodeCount: " << TheOctree->getBranchNodeCount() << std::endl << " IntersectingNodeCount: " << TheOctree->getIntersectingNodeCount() << std::endl << " IntersectingLeafNodeCount: " << TheOctree->getIntersectingLeafNodeCount() << std::endl; //Create the Path Geometry //Generate the Path OctreeAStarAlgorithm AlgorithmObj; SLOG << "Started AStar Search" << std::endl; StartTime = getSystemTime(); Pnt3f Start(-4.01f,1.01f,10.01f),Goal(-4.01f,-0.01f,-7.01f); std::vector<Pnt3f> Path = AlgorithmObj.search(TheOctree,Start,Goal); Path.front() = Start; Path.back() = Goal; SLOG << "Finished AStar Search: " << getSystemTime() - StartTime << " s" << std::endl; NodeRecPtr PathNode = createPathGeometry(Path); PathNode->setTravMask(PathMask); RootNode->addChild(PathNode); NodeRecPtr StartNode = makeSphere(1.0, 2); TransformRecPtr StartNodeTransform = Transform::create(); Matrix StartNodeMatrix; StartNodeMatrix.setTranslate(Start); StartNodeMatrix.setScale(0.1f); StartNodeTransform->setMatrix(StartNodeMatrix); NodeRecPtr StartNodeTransformNode = makeNodeFor(StartNodeTransform); StartNodeTransformNode->addChild(StartNode); StartNodeTransformNode->setTravMask(PathMask); RootNode->addChild(StartNodeTransformNode); NodeRecPtr GoalNode = makeSphere(1.0, 2); TransformRecPtr GoalNodeTransform = Transform::create(); Matrix GoalNodeMatrix; GoalNodeMatrix.setScale(0.1f); GoalNodeMatrix.setTranslate(Goal); GoalNodeTransform->setMatrix(GoalNodeMatrix); NodeRecPtr GoalNodeTransformNode = makeNodeFor(GoalNodeTransform); GoalNodeTransformNode->addChild(GoalNode); GoalNodeTransformNode->setTravMask(PathMask); RootNode->addChild(GoalNodeTransformNode); //Set the background SolidBackgroundRecPtr TheBackground = SolidBackground::create(); TheBackground->setColor(Color3f(0.0f,0.0f,0.0f)); // tell the manager what to manage sceneManager.setRoot (RootNode); sceneManager.getWindow()->getPort(0)->setBackground(TheBackground); // show the whole RootNode sceneManager.showAll(); Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f); Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5); TutorialWindow->openWindow(WinPos, WinSize, "01AStarPathing"); //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(keyPressed, _1)); // Make Torus Node (creates Torus in background of scene) NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16); // Make Main Scene Node and add the Torus NodeRecPtr scene = Node::create(); scene->setCore(Group::create()); scene->addChild(TorusGeometryNode); // Create the Graphics GraphicsRecPtr TutorialGraphics = Graphics2D::create(); // Initialize the LookAndFeelManager to enable default settings LookAndFeelManager::the()->getLookAndFeel()->init(); /****************************************************** Create a Spinner Model. This dictates how the Spinner functions. -setMaximum(int): Determine the Maximum value the Spinner can have. -setMinimum(int): Determine the Minimum value the Spinner can have. -setStepSize(int): Determine the incremental step size. -setValue(SharedFieldRecPtr(new SFInt32(int)): Determine initial starting value of the Spinner. Note: the StepSize can be changed dynamically as done in this Tutorial with ButtonSelectedListeners. ******************************************************/ //Int32SpinnerModelPtr TheModel(new Int32SpinnerModel()); Int32SpinnerModelPtr TheModel(new Int32SpinnerModel()); TheModel->setMaximum(100); TheModel->setMinimum(-100); TheModel->setStepSize(1); TheModel->setValue(boost::any(Int32(0))); /****************************************************** Create a Spinner and and assign it a Model. ******************************************************/ SpinnerRecPtr ExampleSpinner = Spinner::create(); ExampleSpinner->setModel(TheModel); /****************************************************** Create a RadioButtonPanel to allow for certain characteristics of the Spinner to be changed dynamically. See 14RadioButton for more information about RadioButtons. ******************************************************/ RadioButtonRecPtr SingleIncrementButton = RadioButton::create(); RadioButtonRecPtr DoubleIncrementButton = RadioButton::create(); SingleIncrementButton->setText("Increment by 1"); SingleIncrementButton->setPreferredSize(Vec2f(100, 50)); SingleIncrementButton->connectButtonSelected(boost::bind(handleSingleIncbuttonSelected, _1, TheModel)); DoubleIncrementButton->setText("Increment by 2"); DoubleIncrementButton->setPreferredSize(Vec2f(100, 50)); DoubleIncrementButton->connectButtonSelected(boost::bind(handleDoubleIncbuttonSelected, _1, TheModel)); RadioButtonGroupRecPtr SelectionRadioButtonGroup = RadioButtonGroup::create(); SelectionRadioButtonGroup->addButton(SingleIncrementButton); SelectionRadioButtonGroup->addButton(DoubleIncrementButton); SingleIncrementButton->setSelected(true); // Create The Main InternalWindow // Create Background to be used with the Main InternalWindow ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create(); MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5)); LayoutRecPtr MainInternalWindowLayout = FlowLayout::create(); InternalWindowRecPtr MainInternalWindow = InternalWindow::create(); MainInternalWindow->pushToChildren(SingleIncrementButton); MainInternalWindow->pushToChildren(DoubleIncrementButton); MainInternalWindow->pushToChildren(ExampleSpinner); 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); // Create the Drawing Surface UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create(); TutorialDrawingSurface->setGraphics(TutorialGraphics); TutorialDrawingSurface->setEventProducer(TutorialWindow); TutorialDrawingSurface->openWindow(MainInternalWindow); // Create the UI Foreground Object UIForegroundRecPtr TutorialUIForeground = UIForeground::create(); TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface); // Tell the Manager what to manage sceneManager.setRoot(scene); // Add the UI Foreground Object to the Scene ViewportRecPtr TutorialViewport = sceneManager.getWindow()->getPort(0); TutorialViewport->addForeground(TutorialUIForeground); // 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, "29Spinner"); //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(keyPressed, _1)); // Make Torus Node (creates Torus in background of scene) NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16); // Make Main Scene Node and add the Torus NodeRecPtr scene = Node::create(); scene->setCore(Group::create()); scene->addChild(TorusGeometryNode); // Create the Graphics GraphicsRecPtr TutorialGraphics = Graphics2D::create(); // Initialize the LookAndFeelManager to enable default settings LookAndFeelManager::the()->getLookAndFeel()->init(); /****************************************************** Creates some Button components and edit their Text. ******************************************************/ ButtonRecPtr ExampleButton1 = Button::create(); ButtonRecPtr ExampleButton2 = Button::create(); ButtonRecPtr ExampleButton3 = Button::create(); ButtonRecPtr ExampleButton4 = Button::create(); ButtonRecPtr ExampleButton5 = Button::create(); ButtonRecPtr ExampleButton6 = Button::create(); ExampleButton1->setText("This"); ExampleButton2->setText("is a"); ExampleButton3->setText("sample"); ExampleButton4->setText("two"); ExampleButton5->setText("ExamplePanel"); ExampleButton6->setText("layout"); /****************************************************** Create some Flow and BoxLayouts to be used with the Main Frame and two Panels. ******************************************************/ FlowLayoutRecPtr MainInternalWindowLayout = FlowLayout::create(); FlowLayoutRecPtr ExamplePanel1Layout = FlowLayout::create(); FlowLayoutRecPtr ExamplePanel2Layout = FlowLayout::create(); ExamplePanel1Layout->setOrientation(FlowLayout::VERTICAL_ORIENTATION); /****************************************************** Create two Backgrounds to be used with Panels and MainInternalWindow. ******************************************************/ ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create(); ColorLayerRecPtr ExamplePanelBackground = ColorLayer::create(); MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5)); ExamplePanelBackground->setColor(Color4f(0.0,0.0,0.0,1.0)); /****************************************************** Create a Border to be used with the two Panels. ******************************************************/ LineBorderRecPtr ExamplePanelBorder = LineBorder::create(); ExamplePanelBorder->setColor(Color4f(0.9, 0.9, 0.9, 1.0)); ExamplePanelBorder->setWidth(3); /****************************************************** Create MainInternalWindow and two Panel Components and edit their characteristics. -setPreferredSize(Vec2f): Determine the size of the Panel. -pushToChildren(ComponentName): Adds a Component to the ComponentContainer as a Child (meaning it will be displayed within it). -setLayout(LayoutName): Determines the Layout of the ComponentContainer. ******************************************************/ InternalWindowRecPtr MainInternalWindow = InternalWindow::create(); PanelRecPtr ExamplePanel1 = Panel::create(); PanelRecPtr ExamplePanel2 = Panel::create(); // Edit Panel1, Panel2 ExamplePanel1->setPreferredSize(Vec2f(200, 200)); ExamplePanel1->pushToChildren(ExampleButton1); ExamplePanel1->pushToChildren(ExampleButton2); ExamplePanel1->pushToChildren(ExampleButton3); ExamplePanel1->setLayout(ExamplePanel1Layout); ExamplePanel1->setBackgrounds(ExamplePanelBackground); ExamplePanel1->setBorders(ExamplePanelBorder); ExamplePanel2->setPreferredSize(Vec2f(200, 200)); ExamplePanel2->pushToChildren(ExampleButton4); ExamplePanel2->pushToChildren(ExampleButton5); ExamplePanel2->pushToChildren(ExampleButton6); ExamplePanel2->setLayout(ExamplePanel2Layout); ExamplePanel2->setBackgrounds(ExamplePanelBackground); ExamplePanel2->setBorders(ExamplePanelBorder); // Create The Main InternalWindow MainInternalWindow->pushToChildren(ExamplePanel1); MainInternalWindow->pushToChildren(ExamplePanel2); 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); MainInternalWindow->setAllInsets(5); // Create the Drawing Surface UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create(); TutorialDrawingSurface->setGraphics(TutorialGraphics); TutorialDrawingSurface->setEventProducer(TutorialWindow); TutorialDrawingSurface->openWindow(MainInternalWindow); // Create the UI Foreground Object UIForegroundRecPtr TutorialUIForeground = UIForeground::create(); TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface); // Tell the Manager what to manage sceneManager.setRoot(scene); // Add the UI Foreground Object to the Scene ViewportRecPtr TutorialViewport = sceneManager.getWindow()->getPort(0); TutorialViewport->addForeground(TutorialUIForeground); // 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, "10Container"); //Enter main Loop TutorialWindow->mainLoop(); } osgExit(); 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; }
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(keyPressed, _1)); // Make Torus Node (creates Torus in background of scene) NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16); // Make Main Scene Node and add the Torus NodeRecPtr scene = Node::create(); scene->setCore(Group::create()); scene->addChild(TorusGeometryNode); // Create the Graphics GraphicsRecPtr TutorialGraphics = Graphics2D::create(); // Initialize the LookAndFeelManager to enable default settings LookAndFeelManager::the()->getLookAndFeel()->init(); // Create a simple Font to be used with the PasswordField UIFontRecPtr ExampleFont = UIFont::create(); ExampleFont->setSize(16); /****************************************************** Create and edit a PasswordField. A PasswordField is a TextField which allows for text to be entered secretly. -setEchoCar("char"): Determine which character replaces text in the PasswordField. See 16TextField for more information. ******************************************************/ TextFieldRecPtr ExampleTextField = TextField::create(); ExampleTextField->setText(""); ExampleTextField->setEmptyDescText("username"); ExampleTextField->setPreferredSize(Vec2f(130.0f,ExampleTextField->getPreferredSize().y())); PasswordFieldRecPtr ExamplePasswordField = PasswordField::create(); ExamplePasswordField->setPreferredSize(Vec2f(130, ExamplePasswordField->getPreferredSize().y())); ExamplePasswordField->setTextColor(Color4f(0.0, 0.0, 0.0, 1.0)); ExamplePasswordField->setSelectionBoxColor(Color4f(0.0, 0.0, 1.0, 1.0)); ExamplePasswordField->setSelectionTextColor(Color4f(1.0, 1.0, 1.0, 1.0)); //ExamplePasswordField->setText("Text"); // "Text" will be replaced by "####" in the PasswordField ExamplePasswordField->setEchoChar("#"); ExamplePasswordField->setEditable(true); ExamplePasswordField->setFont(ExampleFont); ExamplePasswordField->setSelectionStart(2); ExamplePasswordField->setSelectionEnd(3); ExamplePasswordField->setAlignment(Vec2f(0.0,0.5)); ExamplePasswordField->setEmptyDescText("password"); // Create The Main InternalWindow // Create Background to be used with the Main InternalWindow ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create(); MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5)); FlowLayoutRecPtr MainInternalWindowLayout = FlowLayout::create(); MainInternalWindowLayout->setOrientation(FlowLayout::VERTICAL_ORIENTATION); InternalWindowRecPtr MainInternalWindow = InternalWindow::create(); MainInternalWindow->pushToChildren(ExampleTextField); MainInternalWindow->pushToChildren(ExamplePasswordField); 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); // Create the Drawing Surface UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create(); TutorialDrawingSurface->setGraphics(TutorialGraphics); TutorialDrawingSurface->setEventProducer(TutorialWindow); TutorialDrawingSurface->openWindow(MainInternalWindow); // Create the UI Foreground Object UIForegroundRecPtr TutorialUIForeground = UIForeground::create(); TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface); // Tell the Manager what to manage sceneManager.setRoot(scene); // Add the UI Foreground Object to the Scene ViewportRecPtr TutorialViewport = sceneManager.getWindow()->getPort(0); TutorialViewport->addForeground(TutorialUIForeground); //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, "24PasswordField"); //Enter main Loop TutorialWindow->mainLoop(); } osgExit(); return 0; }
// Initialize GLUT & OpenSG and set up the rootNode int main(int argc, char **argv) { // OSG init osgInit(argc,argv); { // Set up Window WindowEventProducerRecPtr TutorialWindow = createNativeWindow(); TutorialWindow->initWindow(); 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->connectMouseMoved(boost::bind(mouseMoved, _1, &sceneManager)); TutorialWindow->connectMouseDragged(boost::bind(mouseDragged, _1, &sceneManager)); // Tell the Manager what to manage sceneManager.setWindow(TutorialWindow); UInt32 SceneMask(1), NanobotMask(2), PathMask(4); BoostPath SceneFilePath(".//Data//CellParts.osb"); if(argc >= 2) { SceneFilePath = BoostPath(argv[1]); if(!boost::filesystem::exists(SceneFilePath)) { SceneFilePath = BoostPath(".//Data//CellParts.osb"); } } //Make Base Geometry Node NodeRecPtr SceneGeometryNode = SceneFileHandler::the()->read(SceneFilePath.string().c_str()); SceneGeometryNode->setTravMask(SceneMask); if(SceneGeometryNode == NULL) { SceneGeometryNode = makeTorus(1.0, 10.0, 24, 24); } //Construct the Root Node NodeRecPtr RootNode = makeCoredNode<Group>(); RootNode->addChild(SceneGeometryNode); commitChanges(); //Create the Octree SLOG << "Started Building Octree" << std::endl; SLOG << "This may take some time ..." << std::endl; Time StartTime; StartTime = getSystemTime(); OctreePtr TheOctree = Octree::buildTree(RootNode,SceneMask,6,0.5,true); SLOG << "Building Octree: " << getSystemTime() - StartTime << " s" << std::endl; Pnt3f Min,Max; TheOctree->getRoot()->getVolume(); SLOG << "Octree: "<< std::endl << " Depth: " << TheOctree->getDepth() << std::endl << " Bounds: " << TheOctree->getRoot()->getVolume().getMin() << " : " << TheOctree->getRoot()->getVolume().getMax() << std::endl << " NodeCount: " << TheOctree->getNodeCount() << std::endl << " LeafNodeCount: " << TheOctree->getLeafNodeCount() << std::endl << " BranchNodeCount: " << TheOctree->getBranchNodeCount() << std::endl << " IntersectingNodeCount: " << TheOctree->getIntersectingNodeCount() << std::endl << " IntersectingLeafNodeCount: " << TheOctree->getIntersectingLeafNodeCount() << std::endl; //Make the Nanobot Nodes BoostPath NanobotFilePath(".//Data//Nanobot.osb"); NodeRecPtr NanobotGeoNode = SceneFileHandler::the()->read(NanobotFilePath.string().c_str()); NanobotVector Nanobots; UInt32 NumNanobots(3); for(UInt32 i(0) ; i<NumNanobots ; ++i) { NanobotDetails TheDetails; //Get the Transform node for the Nanobot TheDetails._Transform = Transform::create(); Matrix NanobotMatrix; Pnt3f Min,Max; SceneGeometryNode->getVolume().getBounds(Min,Max); Min = Min + ShrinkFactor; Max = Max - ShrinkFactor; NanobotMatrix.setTranslate(randomOpenPosition(Min,Max,TheOctree).subZero()); NanobotMatrix.setScale(0.06f); TheDetails._Transform->setMatrix(NanobotMatrix); TheDetails._Node = makeNodeFor(TheDetails._Transform); TheDetails._Node->addChild(cloneTree(NanobotGeoNode)); TheDetails._Node->setTravMask(NanobotMask); TheDetails._PathVisNode = Node::create(); Nanobots.push_back(TheDetails); makeNanobotPath(Nanobots.back(), TheOctree, TutorialWindow, Min,Max); } for(UInt32 i(0) ; i<Nanobots.size() ; ++i) { RootNode->addChild(Nanobots[i]._Node); RootNode->addChild(Nanobots[i]._PathVisNode); } commitChanges(); //NodeRecPtr StartNode = makeSphere(1.0, 2); //TransformRecPtr StartNodeTransform = Transform::create(); //Matrix StartNodeMatrix; //StartNodeMatrix.setTranslate(Start); //StartNodeMatrix.setScale(0.1f); //StartNodeTransform->setMatrix(StartNodeMatrix); //NodeRecPtr StartNodeTransformNode = makeNodeFor(StartNodeTransform); //StartNodeTransformNode->addChild(StartNode); //StartNodeTransformNode->setTravMask(PathMask); //RootNode->addChild(StartNodeTransformNode); //NodeRecPtr GoalNode = makeSphere(1.0, 2); //TransformRecPtr GoalNodeTransform = Transform::create(); //Matrix GoalNodeMatrix; //GoalNodeMatrix.setScale(0.1f); //GoalNodeMatrix.setTranslate(Goal); //GoalNodeTransform->setMatrix(GoalNodeMatrix); //NodeRecPtr GoalNodeTransformNode = makeNodeFor(GoalNodeTransform); //GoalNodeTransformNode->addChild(GoalNode); //GoalNodeTransformNode->setTravMask(PathMask); //RootNode->addChild(GoalNodeTransformNode); TutorialWindow->connectKeyPressed(boost::bind(keyPressed, _1, TutorialWindow.get(), SceneGeometryNode.get(), TheOctree, Nanobots)); //Set the background SolidBackgroundRecPtr TheBackground = SolidBackground::create(); TheBackground->setColor(Color3f(0.0f,0.0f,0.0f)); // tell the manager what to manage sceneManager.setRoot (RootNode); sceneManager.getWindow()->getPort(0)->setBackground(TheBackground); // show the whole RootNode sceneManager.showAll(); Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f); Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5); TutorialWindow->openWindow(WinPos, WinSize, "01AStarPathing"); //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)); TutorialWindow->connectKeyTyped(boost::bind(keyTyped, _1)); // Tell the Manager what to manage sceneManager.setWindow(TutorialWindow); // Make Torus Node (creates Torus in background of scene) NodeRefPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16); // Make Main Scene Node and add the Torus NodeRefPtr scene = OSG::Node::create(); scene->setCore(OSG::Group::create()); scene->addChild(TorusGeometryNode); // Create the Graphics GraphicsRefPtr 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. ******************************************************/ ButtonRefPtr ExampleButton = OSG::Button::create(); UIFontRefPtr ExampleFont = OSG::UIFont::create(); ExampleFont->setSize(16); /****************************************************** Edit the Button's characteristics. Note: the first 4 functions can be used with any Component and are not specific to Button. -setMinSize(Vec2f): Determine the Minimum Size of the Component. Some Layouts will automatically resize Components; this prevents the Size from going below a certain value. -setMaxSize(Vec2f): Determine the Maximum Size of the Component. -setPreferredSize(Vec2f): Determine the Preferred Size of the Component. This is what the Component will be displayed at unless changed by another Component (such as a Layout). -setToolTipText("Text"): Determine what text is displayed while Mouse is hovering above Component. The word Text will be displayed in this case. Functions specfic to Button: -setText("DesiredText"): Determine the Button's text. It will read DesiredText in this case. -setFont(FontName): Determine the Font to be used on the Button. -setTextColor(Color4f): Determine the Color for the text. -setRolloverTextColor(Color4f): Determine what the text Color will be when the Mouse Cursor is above the Button. -setActiveTextColor(Color4f): Determine what the text Color will be when the Button is pressed (denoted by Active). -setAlignment(Vec2f): Determine the Vertical Alignment of the text. The value is in [0.0, 1.0]. ******************************************************/ ExampleButton->setMinSize(Vec2f(50, 25)); ExampleButton->setMaxSize(Vec2f(200, 100)); ExampleButton->setPreferredSize(Vec2f(100, 50)); ExampleButton->setToolTipText("Button 1 ToolTip"); ExampleButton->setText("Button 1"); 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(1.0,0.0)); // Create an Action and assign it to ExampleButton // This Class is defined above, and will cause the output // window to display "Button 1 Action" when pressed ExampleButton->connectActionPerformed(boost::bind(actionPerformed, _1)); /****************************************************** Create a ToggleButton and determine its characteristics. ToggleButton inherits off of Button, so all characteristsics used above can be used with ToggleButtons as well. The only difference is that when pressed, ToggleButton remains pressed until pressed again. -setSelected(bool): Determine whether the ToggleButton is Selected (true) or deselected (false). ******************************************************/ ToggleButtonRefPtr ExampleToggleButton = OSG::ToggleButton::create(); ExampleToggleButton->setSelected(false); ExampleToggleButton->setText("ToggleMe"); ExampleToggleButton->setToolTipText("Toggle Button ToolTip"); //Button with Image ButtonRefPtr ExampleDrawObjectButton = OSG::Button::create(); ExampleDrawObjectButton->setDrawObjectToTextAlignment(Button::ALIGN_DRAW_OBJECT_RIGHT_OF_TEXT); ExampleDrawObjectButton->setText("Icon"); ExampleDrawObjectButton->setImage(std::string("./Data/Icon.png")); ExampleDrawObjectButton->setActiveImage(std::string("./Data/Icon.png")); ExampleDrawObjectButton->setFocusedImage(std::string("./Data/Icon.png")); ExampleDrawObjectButton->setRolloverImage(std::string("./Data/Icon.png")); ExampleDrawObjectButton->setDisabledImage(std::string("./Data/Icon.png")); // Create The Main InternalWindow // Create Background to be used with the Main InternalWindow ColorLayerRefPtr MainInternalWindowBackground = OSG::ColorLayer::create(); MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5)); InternalWindowRefPtr MainInternalWindow = OSG::InternalWindow::create(); LayoutRefPtr MainInternalWindowLayout = OSG::FlowLayout::create(); MainInternalWindow->pushToChildren(ExampleButton); MainInternalWindow->pushToChildren(ExampleToggleButton); MainInternalWindow->pushToChildren(ExampleDrawObjectButton); 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); // Create the Drawing Surface UIDrawingSurfaceRefPtr TutorialDrawingSurface = UIDrawingSurface::create(); TutorialDrawingSurface->setGraphics(TutorialGraphics); TutorialDrawingSurface->setEventProducer(TutorialWindow); TutorialDrawingSurface->openWindow(MainInternalWindow); // Create the UI Foreground Object UIForegroundRefPtr TutorialUIForeground = OSG::UIForeground::create(); TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface); sceneManager.setRoot(scene); // Add the UI Foreground Object to the Scene ViewportRefPtr TutorialViewport = sceneManager.getWindow()->getPort(0); TutorialViewport->addForeground(TutorialUIForeground); //Create the Documentation Foreground and add it to the viewport SimpleScreenDoc TheSimpleScreenDoc(&sceneManager, TutorialWindow); // Show the whole Scene sceneManager.showAll(); //Attach key controls //Open Window Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f); Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5); TutorialWindow->openWindow(WinPos, WinSize, "01Button"); commitChanges(); //Enter main Loop TutorialWindow->mainLoop(); } osgExit(); return 0; }
// Initialize GLUT & OpenSG and set up the rootNode int main(int argc, char **argv) { // OSG init osgInit(argc,argv); { // Set up Window WindowEventProducerRecPtr TutorialWindow = createNativeWindow(); TutorialWindow->initWindow(); 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->connectMouseMoved(boost::bind(mouseMoved, _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); //Make Base Geometry Node NodeRecPtr TriGeometryBase = makeTorus(0.5, 1.0, 24, 24); //Make Main Scene Node NodeRecPtr scene = makeCoredNode<Group>(); setName(scene, "scene"); NodeRecPtr rootNode = Node::create(); setName(rootNode, "rootNode"); ComponentTransformRecPtr Trans; Trans = ComponentTransform::create(); rootNode->setCore(Trans); // add the torus as a child rootNode->addChild(scene); //Make The Physics Characteristics Node PhysicsCharacteristicsDrawableRecPtr PhysDrawable = PhysicsCharacteristicsDrawable::create(); PhysDrawable->setRoot(rootNode); NodeRecPtr PhysDrawableNode = Node::create(); PhysDrawableNode->setCore(PhysDrawable); PhysDrawableNode->setTravMask(TypeTraits<UInt32>::getMin()); rootNode->addChild(PhysDrawableNode); //Setup Physics Scene PhysicsWorldRecPtr physicsWorld = PhysicsWorld::create(); physicsWorld->setWorldContactSurfaceLayer(0.005); physicsWorld->setAutoDisableFlag(1); physicsWorld->setAutoDisableTime(0.75); physicsWorld->setWorldContactMaxCorrectingVel(100.0); physicsWorld->setGravity(Vec3f(0.0, 0.0, -9.81)); PhysicsHashSpaceRecPtr physicsSpace = PhysicsHashSpace::create(); PhysicsHandlerRecPtr physHandler = PhysicsHandler::create(); physHandler->setWorld(physicsWorld); physHandler->pushToSpaces(physicsSpace); physHandler->setUpdateNode(rootNode); physHandler->attachUpdateProducer(TutorialWindow); /************************************************************************/ /* create spaces, geoms and bodys */ /************************************************************************/ //create a group for our space GroupRecPtr spaceGroup; NodeRecPtr spaceGroupNode = makeCoredNode<Group>(&spaceGroup); //create the ground plane GeometryRecPtr plane; NodeRecPtr planeNode = makeBox(30.0, 30.0, 1.0, 1, 1, 1); plane = dynamic_cast<Geometry*>(planeNode->getCore()); //and its Material SimpleMaterialRecPtr plane_mat = SimpleMaterial::create(); plane_mat->setAmbient(Color3f(0.7,0.7,0.7)); plane_mat->setDiffuse(Color3f(0.9,0.6,1.0)); plane->setMaterial(plane_mat); //create Physical Attachments PhysicsBoxGeomRecPtr planeGeom = PhysicsBoxGeom::create(); planeGeom->setLengths(Vec3f(30.0, 30.0, 1.0)); //add geoms to space for collision planeGeom->setSpace(physicsSpace); //add Attachments to nodes... spaceGroupNode->addAttachment(physicsSpace); spaceGroupNode->addAttachment(physHandler); spaceGroupNode->addAttachment(physicsWorld); spaceGroupNode->addChild(planeNode); planeNode->addAttachment(planeGeom); scene->addChild(spaceGroupNode); //Create Statistics Foreground SimpleStatisticsForegroundRecPtr PhysicsStatForeground = SimpleStatisticsForeground::create(); PhysicsStatForeground->setSize(25); PhysicsStatForeground->setColor(Color4f(0,1,0,0.7)); PhysicsStatForeground->addElement(WindowEventProducer::statWindowLoopTime, "Draw FPS: %r.3f"); PhysicsStatForeground->getCollector()->getElem(WindowEventProducer::statWindowLoopTime, true); PhysicsStatForeground->addElement(RenderAction::statNGeometries, "%d Nodes drawn"); PhysicsStatForeground->getCollector()->getElem(RenderAction::statNGeometries, true); PhysicsStatForeground->addElement(PhysicsHandler::statPhysicsTime, "Physics time: %.3f s"); PhysicsStatForeground->getCollector()->getElem(PhysicsHandler::statPhysicsTime, true); PhysicsStatForeground->addElement(PhysicsHandler::statCollisionTime, "Collision time: %.3f s"); PhysicsStatForeground->getCollector()->getElem(PhysicsHandler::statCollisionTime, true); PhysicsStatForeground->addElement(PhysicsHandler::statSimulationTime, "Simulation time: %.3f s"); PhysicsStatForeground->getCollector()->getElem(PhysicsHandler::statSimulationTime, true); PhysicsStatForeground->addElement(PhysicsHandler::statNCollisions, "%d collisions"); PhysicsStatForeground->getCollector()->getElem(PhysicsHandler::statNCollisions, true); PhysicsStatForeground->addElement(PhysicsHandler::statNCollisionTests, "%d collision tests"); PhysicsStatForeground->getCollector()->getElem(PhysicsHandler::statNCollisionTests, true); PhysicsStatForeground->addElement(PhysicsHandler::statNPhysicsSteps, "%d simulation steps per frame"); PhysicsStatForeground->getCollector()->getElem(PhysicsHandler::statNPhysicsSteps, true); TutorialWindow->connectUpdate(boost::bind(handleStatisticsReset, _1), boost::signals2::at_front); StatCollector::setGlobalCollector(PhysicsStatForeground->getCollector()); SimpleStatisticsForegroundRecPtr RenderStatForeground = SimpleStatisticsForeground::create(); RenderStatForeground->setSize(25); RenderStatForeground->setColor(Color4f(0,1,0,0.7)); // tell the manager what to manage sceneManager.setRoot (rootNode); sceneManager.getWindow()->getPort(0)->addForeground(PhysicsStatForeground); sceneManager.getWindow()->getPort(0)->addForeground(RenderStatForeground); TutorialWindow->connectKeyPressed(boost::bind(keyPressed, _1, TriGeometryBase.get(), spaceGroupNode.get(), PhysDrawableNode.get(), physicsWorld.get(), physicsSpace.get())); // show the whole rootNode sceneManager.getNavigator()->set(Pnt3f(20.0,20.0,10.0), Pnt3f(0.0,0.0,0.0), Vec3f(0.0,0.0,1.0)); sceneManager.getNavigator()->setMotionFactor(1.0f); sceneManager.getCamera()->setFar(10000.0f); sceneManager.getCamera()->setNear(0.1f); Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f); Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5); TutorialWindow->openWindow(WinPos, WinSize, "01SimplePhysics"); //Enter main Loop TutorialWindow->mainLoop(); } osgExit(); return 0; }
// Initialize WIN32 & OpenSG and set up the scene 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(keyPressed, _1)); // Make Torus Node (creates Torus in background of scene) NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16); // Make Main Scene Node and add the Torus NodeRecPtr scene = Node::create(); scene->setCore(Group::create()); scene->addChild(TorusGeometryNode); // Create the Graphics GraphicsRecPtr graphics = Graphics2D::create(); // Initialize the LookAndFeelManager to enable default settings LookAndFeelManager::the()->getLookAndFeel()->init(); /****************************************************** Create the DefaultMutableComboBoxModel and add Elements to it (several Colors in this case). These will be the data values shown in the ComboBox. ******************************************************/ DefaultMutableComboBoxModelRecPtr ExampleComboBoxModel = DefaultMutableComboBoxModel::create(); ExampleComboBoxModel->addElement(boost::any(std::string("Red"))); ExampleComboBoxModel->addElement(boost::any(std::string("Green"))); ExampleComboBoxModel->addElement(boost::any(std::string("Blue"))); ExampleComboBoxModel->addElement(boost::any(std::string("Brown"))); ExampleComboBoxModel->addElement(boost::any(std::string("Yellow"))); ExampleComboBoxModel->addElement(boost::any(std::string("Orange"))); ExampleComboBoxModel->addElement(boost::any(std::string("Violet"))); ExampleComboBoxModel->addElement(boost::any(std::string("Black"))); /****************************************************** Create an editable ComboBox. A ComboBox has a Model just like various other Components. ******************************************************/ //Create the ComboBox ComboBoxRecPtr ExampleComboBox = ComboBox::create(); // Set the Model created above to the ComboBox ExampleComboBox->setModel(ExampleComboBoxModel); // Determine where the ComboBox starts ExampleComboBox->setSelectedIndex(0); /****************************************************** Create a non-editable ComboBox. -setEditable(bool): Determine whether the user can type in the ComboBox or if it is uneditable. In this case, it is set to false. When creating a non-editable ComboBox, a Renderer must also be assigned. For editable ComboBoxes, the ComboBox automatically shows its text due to the nature of the ComboBox. However, when uneditable, this aspect of the ComboBox is disabled, and so to display the selection, a renderer must be created and assigned to the ComboBox. Note: as with Sliders and ScrollBars, having the same Model assigned causes the ComboBoxes to be tied together. ******************************************************/ // Create another ComboBox ComboBoxRecPtr ExampleUneditableComboBox = ComboBox::create(); // Set it to be uneditable ExampleUneditableComboBox->setEditable(false); ExampleUneditableComboBox->setModel(ExampleComboBoxModel); // Create The Main InternalWindow // Create Background to be used with the Main InternalWindow ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create(); MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5)); LayoutRecPtr MainInternalWindowLayout = FlowLayout::create(); InternalWindowRecPtr MainInternalWindow = InternalWindow::create(); MainInternalWindow->pushToChildren(ExampleComboBox); MainInternalWindow->pushToChildren(ExampleUneditableComboBox); 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); //Create the Drawing Surface UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create(); TutorialDrawingSurface->setGraphics(graphics); TutorialDrawingSurface->setEventProducer(TutorialWindow); TutorialDrawingSurface->openWindow(MainInternalWindow); // Create the UI Foreground Object UIForegroundRecPtr foreground = UIForeground::create(); foreground->setDrawingSurface(TutorialDrawingSurface); // Tell the manager what to manage sceneManager.setRoot(scene); // Add the UI Foreground Object to the Scene ViewportRecPtr viewport = sceneManager.getWindow()->getPort(0); viewport->addForeground(foreground); //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, "33ComboBox"); //Enter main Loop TutorialWindow->mainLoop(); } osgExit(); return 0; }
// Initialize WIN32 & OpenSG and set up the scene 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(keyPressed, _1)); // Make Torus Node (creates Torus in background of scene) NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16); // Make Main Scene Node and add the Torus NodeRecPtr scene = Node::create(); scene->setCore(Group::create()); scene->addChild(TorusGeometryNode); // Create the Graphics GraphicsRecPtr graphics = Graphics2D::create(); // Initialize the LookAndFeelManager to enable default settings LookAndFeelManager::the()->getLookAndFeel()->init(); /****************************************************** Create the DerivedFieldContainerComboBoxModel and add Elements to it (derived FieldContainerTypes ). These will be the data values shown in the ComboBox. ******************************************************/ DerivedFieldContainerComboBoxModelRecPtr ExampleComboBoxModel = DerivedFieldContainerComboBoxModel::create(); ExampleComboBoxModel->editMFDerivedFieldContainerTypes()->push_back(std::string(Component::getClassType().getCName())); /****************************************************** Create an editable ComboBox. A ComboBox has a Model just like various other Components. ******************************************************/ //Create the ComboBox ComboBoxRecPtr ExampleUneditableComboBox = ComboBox::create(); // Set it to be uneditable ExampleUneditableComboBox->setEditable(false); ExampleUneditableComboBox->setModel(ExampleComboBoxModel); ExampleUneditableComboBox->setSelectedIndex(0); ExampleUneditableComboBox->setPreferredSize(Vec2f(160.0f,ExampleUneditableComboBox->getPreferredSize().y())); // Create The Main InternalWindow // Create Background to be used with the Main InternalWindow ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create(); MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5)); FlowLayoutRecPtr MainInternalWindowLayout = FlowLayout::create(); MainInternalWindowLayout->setMinorAxisAlignment(0.2f); InternalWindowRecPtr MainInternalWindow = InternalWindow::create(); MainInternalWindow->pushToChildren(ExampleUneditableComboBox); MainInternalWindow->setLayout(MainInternalWindowLayout); MainInternalWindow->setBackgrounds(MainInternalWindowBackground); MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f)); MainInternalWindow->setScalingInDrawingSurface(Vec2f(0.8f,0.8f)); MainInternalWindow->setDrawTitlebar(false); MainInternalWindow->setResizable(false); //Create the Drawing Surface UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create(); TutorialDrawingSurface->setGraphics(graphics); TutorialDrawingSurface->setEventProducer(TutorialWindow); TutorialDrawingSurface->openWindow(MainInternalWindow); // Create the UI Foreground Object UIForegroundRecPtr foreground = UIForeground::create(); foreground->setDrawingSurface(TutorialDrawingSurface); // Tell the manager what to manage sceneManager.setRoot(scene); // Add the UI Foreground Object to the Scene ViewportRecPtr viewport = sceneManager.getWindow()->getPort(0); viewport->addForeground(foreground); // 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, "42FieldContainerComboBox"); //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(keyPressed, _1)); // Make Torus Node (creates Torus in background of scene) NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16); // Make Main Scene Node and add the Torus NodeRecPtr scene = Node::create(); scene->setCore(Group::create()); scene->addChild(TorusGeometryNode); // Create the Graphics GraphicsRecPtr TutorialGraphics = Graphics2D::create(); // Initialize the LookAndFeelManager to enable default settings LookAndFeelManager::the()->getLookAndFeel()->init(); /****************************************************** Creates some Button components ******************************************************/ ButtonRecPtr ExampleButton1 = Button::create(); ButtonRecPtr ExampleButton2 = Button::create(); ButtonRecPtr ExampleButton3 = Button::create(); ButtonRecPtr ExampleButton4 = Button::create(); ButtonRecPtr ExampleButton5 = Button::create(); ButtonRecPtr ExampleButton6 = Button::create(); /****************************************************** Create OverlayLayout. This layout simply places all Components within it on top of each other. They are placed in reverse order of how they are added to the MainFrame (Components added first are rendered last, those added last are rendered first). Note: OverlayLayout has no options which can be set. ******************************************************/ OverlayLayoutRecPtr MainInternalWindowLayout = OverlayLayout::create(); // OverlayLayout has no options to edit! // NOTHING : ) /****************************************************** Create and edit some Button Components. ******************************************************/ ExampleButton1->setPreferredSize(Vec2f(50,50)); ExampleButton1->setMaxSize(Vec2f(50,50)); ExampleButton2->setPreferredSize(Vec2f(300,50)); ExampleButton3->setPreferredSize(Vec2f(50,300)); // Create The Main InternalWindow // Create Background to be used with the Main InternalWindow ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create(); MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5)); InternalWindowRecPtr MainInternalWindow = InternalWindow::create(); MainInternalWindow->pushToChildren(ExampleButton1); MainInternalWindow->pushToChildren(ExampleButton2); MainInternalWindow->pushToChildren(ExampleButton3); MainInternalWindow->pushToChildren(ExampleButton4); MainInternalWindow->pushToChildren(ExampleButton5); MainInternalWindow->pushToChildren(ExampleButton6); 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); // Create the Drawing Surface UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create(); TutorialDrawingSurface->setGraphics(TutorialGraphics); TutorialDrawingSurface->setEventProducer(TutorialWindow); TutorialDrawingSurface->openWindow(MainInternalWindow); // Create the UI Foreground Object UIForegroundRecPtr TutorialUIForeground = UIForeground::create(); TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface); // Tell the Manager what to manage sceneManager.setRoot(scene); // Add the UI Foreground Object to the Scene ViewportRecPtr TutorialViewport = sceneManager.getWindow()->getPort(0); TutorialViewport->addForeground(TutorialUIForeground); // 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, "08OverlayLayout"); //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(keyPressed, _1)); NodeRecPtr Root(NULL); if(argc == 2) { Root = SceneFileHandler::the()->read(argv[1]); } if(Root == NULL) { // Make Torus Node (creates Torus in background of Root) NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16); NodeRecPtr TorusNode = Node::create(); TorusNode->setCore(Transform::create()); TorusNode->addChild(TorusGeometryNode); NodeRecPtr SphereGeometryNode = makeSphere(2,1.0f); NodeRecPtr BoxGeometryNode = makeBox(1.0,1.0,1.0,1,1,1); // Make Main Scene Node and add the Torus Root = Node::create(); Root->setCore(Group::create()); Root->addChild(TorusNode); Root->addChild(SphereGeometryNode); Root->addChild(BoxGeometryNode); } // Create the Graphics GraphicsRecPtr TutorialGraphics = Graphics2D::create(); // Initialize the LookAndFeelManager to enable default settings LookAndFeelManager::the()->getLookAndFeel()->init(); // Create The Main InternalWindow // Create Background to be used with the Main InternalWindow ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create(); MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5)); LayoutRecPtr MainInternalWindowLayout = FlowLayout::create(); //Import InternalWindow(s) from XML file std::vector<InternalWindowRecPtr> StoreWindows; FCFileType::FCPtrStore NewContainers; NewContainers = FCFileHandler::the()->read(BoostPath("./Data/55ComponentTree.xml")); //Store each window found in the XML in the vector FCFileType::FCPtrStore::iterator Itor; for(Itor = NewContainers.begin(); Itor != NewContainers.end(); ++Itor) { if( (*Itor)->getType() == (InternalWindow::getClassType())) { StoreWindows.push_back(dynamic_pointer_cast<InternalWindow>(*Itor)); } } //Tree Model FieldContainerTreeModelRecPtr TheTreeModel = FieldContainerTreeModel::create(); TheTreeModel->setRoot(StoreWindows.front()); //TheTreeModel->setShowPtrFields(false); //TheTreeModel->setShowDataFields(false); //TheTreeModel->setShowParentPtrFields(false); //TheTreeModel->setShowChildPtrFields(false); TheTreeModel->setShowAttachments(false); //TheTreeModel->setShowCallbackFunctors(false); //Tree Component Generator FieldContainerFieldPathComponentGeneratorRecPtr TheTreeComponentGenerator = FieldContainerFieldPathComponentGenerator::create(); //Create the Tree TreeRecPtr TheTree = Tree::create(); TheTree->setPreferredSize(Vec2f(100, 500)); TheTree->setRootVisible(true); TheTree->setModel(TheTreeModel); TheTree->setCellGenerator(TheTreeComponentGenerator); setName(TheTree, std::string("TheTree")); // Create a ScrollPanel for easier viewing of the List (see 27ScrollPanel) ScrollPanelRecPtr ExampleScrollPanel = ScrollPanel::create(); ExampleScrollPanel->setPreferredSize(Vec2f(350,500)); //ExampleScrollPanel->setHorizontalResizePolicy(ScrollPanel::RESIZE_TO_VIEW); //ExampleScrollPanel->setVerticalResizePolicy(ScrollPanel::RESIZE_TO_VIEW); ExampleScrollPanel->setViewComponent(TheTree); setName(ExampleScrollPanel, std::string("ExampleScrollPanel")); //Show Buttons CheckboxButtonRecPtr ShowMultiFieldsButton = CheckboxButton::create(); CheckboxButtonRecPtr ShowSingleFieldsButton = CheckboxButton::create(); CheckboxButtonRecPtr ShowPtrFieldsButton = CheckboxButton::create(); CheckboxButtonRecPtr ShowDataFieldsButton = CheckboxButton::create(); CheckboxButtonRecPtr ShowParentPtrFieldsButton = CheckboxButton::create(); CheckboxButtonRecPtr ShowChildPtrFieldsButton = CheckboxButton::create(); CheckboxButtonRecPtr ShowAttachmentsButton = CheckboxButton::create(); CheckboxButtonRecPtr ShowCallbackFunctorsButton = CheckboxButton::create(); CheckboxButtonRecPtr ShowInternalFieldsButton = CheckboxButton::create(); ShowMultiFieldsButton->setText("Multi Fields"); ShowMultiFieldsButton->setPreferredSize(Vec2f(120.0f,ShowMultiFieldsButton->getPreferredSize().y())); ShowMultiFieldsButton->setAlignment(Vec2f(0.0f,0.5f)); ShowSingleFieldsButton->setText("Single Fields"); ShowSingleFieldsButton->setPreferredSize(Vec2f(120.0f,ShowSingleFieldsButton->getPreferredSize().y())); ShowSingleFieldsButton->setAlignment(Vec2f(0.0f,0.5f)); ShowPtrFieldsButton->setText("Ptr Fields"); ShowPtrFieldsButton->setPreferredSize(Vec2f(120.0f,ShowPtrFieldsButton->getPreferredSize().y())); ShowPtrFieldsButton->setAlignment(Vec2f(0.0f,0.5f)); ShowDataFieldsButton->setText("Data Fields"); ShowDataFieldsButton->setPreferredSize(Vec2f(120.0f,ShowDataFieldsButton->getPreferredSize().y())); ShowDataFieldsButton->setAlignment(Vec2f(0.0f,0.5f)); ShowParentPtrFieldsButton->setText("ParentPtr Fields"); ShowParentPtrFieldsButton->setPreferredSize(Vec2f(120.0f,ShowParentPtrFieldsButton->getPreferredSize().y())); ShowParentPtrFieldsButton->setAlignment(Vec2f(0.0f,0.5f)); ShowChildPtrFieldsButton->setText("ChildPtr Fields"); ShowChildPtrFieldsButton->setPreferredSize(Vec2f(120.0f,ShowChildPtrFieldsButton->getPreferredSize().y())); ShowChildPtrFieldsButton->setAlignment(Vec2f(0.0f,0.5f)); ShowAttachmentsButton->setText("Attachments"); ShowAttachmentsButton->setPreferredSize(Vec2f(120.0f,ShowAttachmentsButton->getPreferredSize().y())); ShowAttachmentsButton->setAlignment(Vec2f(0.0f,0.5f)); ShowCallbackFunctorsButton->setText("Callback Functors"); ShowCallbackFunctorsButton->setPreferredSize(Vec2f(120.0f,ShowCallbackFunctorsButton->getPreferredSize().y())); ShowCallbackFunctorsButton->setAlignment(Vec2f(0.0f,0.5f)); ShowInternalFieldsButton->setText("Internal Fields"); ShowInternalFieldsButton->setPreferredSize(Vec2f(120.0f,ShowInternalFieldsButton->getPreferredSize().y())); ShowInternalFieldsButton->setAlignment(Vec2f(0.0f,0.5f)); ShowCheckboxesController CheckboxesController(TheTreeModel, ShowMultiFieldsButton, ShowSingleFieldsButton, ShowPtrFieldsButton, ShowDataFieldsButton, ShowParentPtrFieldsButton, ShowChildPtrFieldsButton, ShowAttachmentsButton, ShowCallbackFunctorsButton, ShowInternalFieldsButton); PanelRecPtr OptionsPanel = Panel::create(); FlowLayoutRecPtr OptionsPanelLayout = FlowLayout::create(); OptionsPanel->setLayout(OptionsPanelLayout); OptionsPanel->setPreferredSize(Vec2f(250.0f, 300.0f)); OptionsPanel->pushToChildren(ShowMultiFieldsButton); OptionsPanel->pushToChildren(ShowSingleFieldsButton); OptionsPanel->pushToChildren(ShowPtrFieldsButton); OptionsPanel->pushToChildren(ShowDataFieldsButton); OptionsPanel->pushToChildren(ShowInternalFieldsButton); OptionsPanel->pushToChildren(ShowParentPtrFieldsButton); OptionsPanel->pushToChildren(ShowChildPtrFieldsButton); OptionsPanel->pushToChildren(ShowAttachmentsButton); OptionsPanel->pushToChildren(ShowCallbackFunctorsButton); InternalWindowRecPtr MainInternalWindow = InternalWindow::create(); MainInternalWindow->pushToChildren(ExampleScrollPanel); MainInternalWindow->pushToChildren(OptionsPanel); MainInternalWindow->setLayout(MainInternalWindowLayout); MainInternalWindow->setBackgrounds(MainInternalWindowBackground); MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f)); MainInternalWindow->setScalingInDrawingSurface(Vec2f(0.85f,0.85f)); MainInternalWindow->setDrawTitlebar(false); MainInternalWindow->setResizable(false); setName(MainInternalWindow, std::string("MainInternalWindow")); // Create the Drawing Surface UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create(); TutorialDrawingSurface->setGraphics(TutorialGraphics); TutorialDrawingSurface->setEventProducer(TutorialWindow); TutorialDrawingSurface->openWindow(MainInternalWindow); TutorialDrawingSurface->openWindow(StoreWindows.back()); // Create the UI Foreground Object UIForegroundRecPtr TutorialUIForeground = UIForeground::create(); TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface); // Tell the Manager what to manage sceneManager.setRoot(Root); // Add the UI Foreground Object to the Scene ViewportRecPtr TutorialViewport = sceneManager.getWindow()->getPort(0); TutorialViewport->addForeground(TutorialUIForeground); // 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, "56FieldContainerTree"); //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(keyPressed, _1)); // Make Torus Node (creates Torus in background of scene) NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16); // Make Main Scene Node and add the Torus NodeRecPtr scene = Node::create(); scene->setCore(Group::create()); scene->addChild(TorusGeometryNode); // Create the Graphics GraphicsRecPtr TutorialGraphics = 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. ******************************************************/ LineBorderRecPtr ChangableBorder = LineBorder::create(); ChangableBorder->setColor(Color4f(0.0,0.0,0.0,1.0)); ColorLayerRecPtr ChangableBackground = ColorLayer::create(); ChangableBackground->setColor(Color4f(1.0,1.0,1.0,1.0)); LabelRecPtr ChangableLabel = Label::create(); ChangableLabel->setText("Changable"); ChangableLabel->setBorders(ChangableBorder); ChangableLabel->setBackgrounds(ChangableBackground); //Command Buttons UndoManagerPtr TheUndoManager = UndoManager::create(); CommandManagerPtr TheCommandManager = CommandManager::create(TheUndoManager); ButtonRecPtr BorderRedButton = Button::create(); BorderRedButton->setText("Border Red"); BorderRedButton->setPreferredSize(Vec2f(85, 20)); BorderRedButton->connectActionPerformed(boost::bind(handleSetBorderColorAction, _1, TheCommandManager, ChangableBorder.get(), Color4f(1.0,0.0,0.0,1.0))); ButtonRecPtr BorderGreenButton = Button::create(); BorderGreenButton->setText("Border Green"); BorderGreenButton->setPreferredSize(Vec2f(85, 20)); BorderGreenButton->connectActionPerformed(boost::bind(handleSetBorderColorAction, _1, TheCommandManager, ChangableBorder.get(), Color4f(0.0,1.0,0.0,1.0))); ButtonRecPtr BorderBlueButton = Button::create(); BorderBlueButton->setText("Border Blue"); BorderBlueButton->setPreferredSize(Vec2f(85, 20)); BorderBlueButton->connectActionPerformed(boost::bind(handleSetBorderColorAction, _1, TheCommandManager, ChangableBorder.get(), Color4f(0.0,0.0,1.0,1.0))); //Background ButtonRecPtr BackgroundRedButton = Button::create(); BackgroundRedButton->setText("Background Red"); BackgroundRedButton->setPreferredSize(Vec2f(105, 20)); BackgroundRedButton->connectActionPerformed(boost::bind(handleSetBackgroundColorAction, _1, TheCommandManager, ChangableBackground.get(), Color4f(1.0,0.0,0.0,1.0))); ButtonRecPtr BackgroundGreenButton = Button::create(); BackgroundGreenButton->setText("Background Green"); BackgroundGreenButton->setPreferredSize(Vec2f(105, 20)); BackgroundGreenButton->connectActionPerformed(boost::bind(handleSetBackgroundColorAction, _1, TheCommandManager, ChangableBackground.get(), Color4f(0.0,1.0,0.0,1.0))); ButtonRecPtr BackgroundBlueButton = Button::create(); BackgroundBlueButton->setText("Background Blue"); BackgroundBlueButton->setPreferredSize(Vec2f(105, 20)); BackgroundBlueButton->connectActionPerformed(boost::bind(handleSetBackgroundColorAction, _1, TheCommandManager, ChangableBackground.get(), Color4f(0.0,0.0,1.0,1.0))); //UndoList DefaultListModelRecPtr UndoRedoListModel = DefaultListModel::create(); UndoRedoListModel->pushBack(boost::any(std::string("Top"))); ListRecPtr UndoRedoList = List::create(); UndoRedoList->setPreferredSize(Vec2f(200, 300)); UndoRedoList->setOrientation(List::VERTICAL_ORIENTATION); UndoRedoList->setModel(UndoRedoListModel); UndoRedoList->getSelectionModel()->connectSelectionChanged(boost::bind(handleUndoRedoListSelectionChanged, _1, UndoRedoList.get(), TheUndoManager)); ButtonRecPtr UndoButton = Button::create(); UndoButton->setText("Undo"); UndoButton->setEnabled(TheUndoManager->numberOfUndos() != 0); UndoButton->connectActionPerformed(boost::bind(handleUndoButtonAction, _1, TheUndoManager)); ButtonRecPtr RedoButton = Button::create(); RedoButton->setText("Redo"); RedoButton->setEnabled(TheUndoManager->numberOfRedos() != 0); RedoButton->connectActionPerformed(boost::bind(handleRedoButtonAction, _1, TheUndoManager)); // Create a ScrollPanel for easier viewing of the List (see 27ScrollPanel) ScrollPanelRecPtr UndoRedoScrollPanel = ScrollPanel::create(); UndoRedoScrollPanel->setPreferredSize(Vec2f(200,200)); UndoRedoScrollPanel->setHorizontalResizePolicy(ScrollPanel::RESIZE_TO_VIEW); UndoRedoScrollPanel->setViewComponent(UndoRedoList); // Create The Main InternalWindow // Create Background to be used with the Main InternalWindow ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create(); MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5)); InternalWindowRecPtr MainInternalWindow = InternalWindow::create(); LayoutRecPtr MainInternalWindowLayout = FlowLayout::create(); MainInternalWindow->pushToChildren(BorderRedButton); MainInternalWindow->pushToChildren(BorderGreenButton); MainInternalWindow->pushToChildren(BorderBlueButton); MainInternalWindow->pushToChildren(BackgroundRedButton); MainInternalWindow->pushToChildren(BackgroundGreenButton); MainInternalWindow->pushToChildren(BackgroundBlueButton); MainInternalWindow->pushToChildren(ChangableLabel); MainInternalWindow->pushToChildren(UndoRedoScrollPanel); MainInternalWindow->pushToChildren(UndoButton); MainInternalWindow->pushToChildren(RedoButton); MainInternalWindow->setLayout(MainInternalWindowLayout); MainInternalWindow->setBackgrounds(MainInternalWindowBackground); MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f)); MainInternalWindow->setScalingInDrawingSurface(Vec2f(0.95f,0.95f)); MainInternalWindow->setDrawTitlebar(false); MainInternalWindow->setResizable(false); TheUndoManager->connectStateChanged(boost::bind(handleUndoManagerStateChanged, _1, UndoRedoListModel.get(), TheUndoManager, UndoButton.get(), RedoButton.get())); // Create the Drawing Surface UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create(); TutorialDrawingSurface->setGraphics(TutorialGraphics); TutorialDrawingSurface->setEventProducer(TutorialWindow); TutorialDrawingSurface->openWindow(MainInternalWindow); // Create the UI Foreground Object UIForegroundRecPtr TutorialUIForeground = UIForeground::create(); TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface); // Tell the Manager what to manage sceneManager.setRoot(scene); // Add the UI Foreground Object to the Scene ViewportRecPtr TutorialViewport = sceneManager.getWindow()->getPort(0); TutorialViewport->addForeground(TutorialUIForeground); //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, "40UndoableCommand"); //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(keyPressed, _1)); NodeRecPtr Root(NULL); if(argc == 2) { Root = SceneFileHandler::the()->read(argv[1]); } if(Root == NULL) { // Make Torus Node (creates Torus in background of Root) NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16); setName(TorusGeometryNode, std::string("Torus")); NodeRecPtr TorusNode = Node::create(); TorusNode->setCore(Transform::create()); TorusNode->addChild(TorusGeometryNode); setName(TorusNode, std::string("Torus Transform")); NodeRecPtr SphereGeometryNode = makeSphere(2,1.0f); setName(SphereGeometryNode, std::string("Sphere")); NodeRecPtr BoxGeometryNode = makeBox(1.0,1.0,1.0,1,1,1); setName(BoxGeometryNode, std::string("Box")); // Make Main Scene Node and add the Torus Root = Node::create(); Root->setCore(Group::create()); Root->addChild(TorusNode); Root->addChild(SphereGeometryNode); Root->addChild(BoxGeometryNode); setName(Root, std::string("Root")); } // Create the Graphics GraphicsRecPtr TutorialGraphics = Graphics2D::create(); // Initialize the LookAndFeelManager to enable default settings LookAndFeelManager::the()->getLookAndFeel()->init(); //Tree Model SceneGraphTreeModelRecPtr TheTreeModel = SceneGraphTreeModel::create(); TheTreeModel->setRoot(Root); //Create the Tree TreeRecPtr TheTree = Tree::create(); TheTree->setPreferredSize(Vec2f(100, 500)); TheTree->setModel(TheTreeModel); // Create a ScrollPanel for easier viewing of the List (see 27ScrollPanel) BorderLayoutConstraintsRecPtr SceneTreeConstraints = BorderLayoutConstraints::create(); SceneTreeConstraints->setRegion(BorderLayoutConstraints::BORDER_WEST); ScrollPanelRecPtr ExampleScrollPanel = ScrollPanel::create(); ExampleScrollPanel->setPreferredSize(Vec2f(350,300)); ExampleScrollPanel->setConstraints(SceneTreeConstraints); //ExampleScrollPanel->setHorizontalResizePolicy(ScrollPanel::RESIZE_TO_VIEW); //ExampleScrollPanel->setVerticalResizePolicy(ScrollPanel::RESIZE_TO_VIEW); ExampleScrollPanel->setViewComponent(TheTree); //Details Panel Labels LabelRecPtr NodeNameLabel = Label::create(); NodeNameLabel->setText("Name"); NodeNameLabel->setPreferredSize(Vec2f(100.0f, 20.0f)); LabelRecPtr NodeNameValueLabel = Label::create(); NodeNameValueLabel->setPreferredSize(Vec2f(300.0f, 20.0f)); LabelRecPtr NodeCoreTypeLabel = Label::create(); NodeCoreTypeLabel->setText("Core Type"); NodeCoreTypeLabel->setPreferredSize(Vec2f(100.0f, 20.0f)); LabelRecPtr NodeCoreTypeValueLabel = Label::create(); NodeCoreTypeValueLabel->setPreferredSize(Vec2f(300.0f, 20.0f)); LabelRecPtr NodeMinLabel = Label::create(); NodeMinLabel->setText("Min"); NodeMinLabel->setPreferredSize(Vec2f(100.0f, 20.0f)); LabelRecPtr NodeMinValueLabel = Label::create(); NodeMinValueLabel->setPreferredSize(Vec2f(300.0f, 20.0f)); LabelRecPtr NodeMaxLabel = Label::create(); NodeMaxLabel->setText("Max"); NodeMaxLabel->setPreferredSize(Vec2f(100.0f, 20.0f)); LabelRecPtr NodeMaxValueLabel = Label::create(); NodeMaxValueLabel->setPreferredSize(Vec2f(300.0f, 20.0f)); LabelRecPtr NodeCenterLabel = Label::create(); NodeCenterLabel->setText("Center"); NodeCenterLabel->setPreferredSize(Vec2f(100.0f, 20.0f)); LabelRecPtr NodeCenterValueLabel = Label::create(); NodeCenterValueLabel->setPreferredSize(Vec2f(300.0f, 20.0f)); LabelRecPtr NodeTriCountLabel = Label::create(); NodeTriCountLabel->setText("TriCount"); NodeTriCountLabel->setPreferredSize(Vec2f(100.0f, 20.0f)); LabelRecPtr NodeTriCountValueLabel = Label::create(); NodeTriCountValueLabel->setPreferredSize(Vec2f(300.0f, 20.0f)); LabelRecPtr NodeTravMaskLabel = Label::create(); NodeTravMaskLabel->setText("Traversal Mask"); NodeTravMaskLabel->setPreferredSize(Vec2f(100.0f, 20.0f)); LabelRecPtr NodeTravMaskValueLabel = Label::create(); NodeTravMaskValueLabel->setPreferredSize(Vec2f(300.0f, 20.0f)); //Details Panel BorderLayoutConstraintsRecPtr NodeDetailPanelConstraints = BorderLayoutConstraints::create(); NodeDetailPanelConstraints->setRegion(BorderLayoutConstraints::BORDER_SOUTH); GridLayoutRecPtr NodeDetailPanelLayout = GridLayout::create(); NodeDetailPanelLayout->setRows(7); NodeDetailPanelLayout->setColumns(2); NodeDetailPanelLayout->setHorizontalGap(2); NodeDetailPanelLayout->setVerticalGap(2); PanelRecPtr NodeDetailPanel = Panel::create(); NodeDetailPanel->setConstraints(NodeDetailPanelConstraints); NodeDetailPanel->setPreferredSize(Vec2f(100.0f, 200.0f)); NodeDetailPanel->setLayout(NodeDetailPanelLayout); NodeDetailPanel->pushToChildren(NodeNameLabel); NodeDetailPanel->pushToChildren(NodeNameValueLabel); NodeDetailPanel->pushToChildren(NodeCoreTypeLabel); NodeDetailPanel->pushToChildren(NodeCoreTypeValueLabel); NodeDetailPanel->pushToChildren(NodeMinLabel); NodeDetailPanel->pushToChildren(NodeMinValueLabel); NodeDetailPanel->pushToChildren(NodeMaxLabel); NodeDetailPanel->pushToChildren(NodeMaxValueLabel); NodeDetailPanel->pushToChildren(NodeCenterLabel); NodeDetailPanel->pushToChildren(NodeCenterValueLabel); NodeDetailPanel->pushToChildren(NodeTriCountLabel); NodeDetailPanel->pushToChildren(NodeTriCountValueLabel); NodeDetailPanel->pushToChildren(NodeTravMaskLabel); NodeDetailPanel->pushToChildren(NodeTravMaskValueLabel); SelectionHandler TheTreeSelectionHandler(TheTree, &sceneManager, NodeNameValueLabel, NodeCoreTypeValueLabel, NodeMinValueLabel, NodeMaxValueLabel, NodeCenterValueLabel, NodeTriCountValueLabel, NodeTravMaskValueLabel); // Create The Main InternalWindow // Create Background to be used with the Main InternalWindow ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create(); MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5)); LayoutRecPtr MainInternalWindowLayout = BorderLayout::create(); InternalWindowRecPtr MainInternalWindow = InternalWindow::create(); MainInternalWindow->pushToChildren(ExampleScrollPanel); MainInternalWindow->pushToChildren(NodeDetailPanel); MainInternalWindow->setLayout(MainInternalWindowLayout); MainInternalWindow->setBackgrounds(NULL); MainInternalWindow->setBorders(NULL); MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.0f,0.5f)); MainInternalWindow->setScalingInDrawingSurface(Vec2f(1.0,1.0)); MainInternalWindow->setDrawTitlebar(false); MainInternalWindow->setResizable(false); // Create the Drawing Surface UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create(); TutorialDrawingSurface->setGraphics(TutorialGraphics); TutorialDrawingSurface->setEventProducer(TutorialWindow); TutorialDrawingSurface->openWindow(MainInternalWindow); // Create the UI Foreground Object UIForegroundRecPtr TutorialUIForeground = UIForeground::create(); TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface); // Tell the Manager what to manage sceneManager.setRoot(Root); // Add the UI Foreground Object to the Scene ViewportRecPtr TutorialViewport = sceneManager.getWindow()->getPort(0); TutorialViewport->addForeground(TutorialUIForeground); //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, "52SceneGraphTree"); //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(keyPressed, _1)); // Make Torus Node (creates Torus in background of scene) NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16); // Make Main Scene Node and add the Torus NodeRecPtr scene = Node::create(); scene->setCore(Group::create()); scene->addChild(TorusGeometryNode); // Create the Graphics GraphicsRecPtr TutorialGraphics = Graphics2D::create(); // Initialize the LookAndFeelManager to enable default settings LookAndFeelManager::the()->getLookAndFeel()->init(); /****************************************************** Create a Panel containing Buttons to add to ScrollPanel using a function (located at bottom of this file) ******************************************************/ PanelRecPtr ExampleViewablePanel = createPanelWithButtons(); /****************************************************** Create a UIViewport to use with the ScrollPanel. This sets up a secondary TutorialViewport inside the ScrollPanel. Without this, the ScrollPanel would not function correctly. The Panel created above is added to be viewed in the UIViewport and the size and position are set. ******************************************************/ UIViewportRecPtr ScrollPanelUIViewport = UIViewport::create(); ScrollPanelUIViewport->setViewComponent(ExampleViewablePanel); ScrollPanelUIViewport->setViewPosition(Pnt2f(150,150)); ScrollPanelUIViewport->setPreferredSize(Vec2f(200,200)); /****************************************************** Create the ScrollPanel itself. -setHorizontalResizePolicy(ScrollPanel:: ENUM): Determines the Horizontal resize policy. The ScrollPanel will automatically resize itself to the Size of its Component within for RESIZE_TO_VIEW, or add a ScrollBar as needed for NO_RESIZE. Takes NO_RESIZE and RESIZE_TO_VIEW arguments. -setVerticalResizePolicy(ScrollPanel:: ENUM): Determines the Vertical resize policy. The ScrollPanel will automatically resize itself to the Size of its Component within for RESIZE_TO_VIEW, or add a ScrollBar as needed for NO_RESIZE. Takes NO_RESIZE and RESIZE_TO_VIEW arguments. -setViewComponent(Component): Determine which Component will be added into the ScrollPanel. Note that this must be the same as the UIViewport created above and does not require a begin/endEditCP. ******************************************************/ ScrollPanelRecPtr ExampleScrollPanel = ScrollPanel::create(); ExampleScrollPanel->setPreferredSize(Vec2f(100,100)); ExampleScrollPanel->setVerticalScrollBarAlignment(ScrollPanel::SCROLLBAR_ALIGN_LEFT); ExampleScrollPanel->setHorizontalScrollBarAlignment(ScrollPanel::SCROLLBAR_ALIGN_BOTTOM); //ExampleScrollPanel->setHorizontalResizePolicy(ScrollPanel::RESIZE_TO_VIEW); //ExampleScrollPanel->setVerticalResizePolicy(ScrollPanel::RESIZE_TO_VIEW); ExampleScrollPanel->setViewComponent(ExampleViewablePanel); /****************************************************** Create two ScrollBars. First, create a DefaultBoundedRangeModel. This determines some characteristics of the Scrollbar. Note that you can link several ScollBars to the same DefaultBoundedRangeModel; this will cause them to move at the same time. -.setMinimum(int): Determine a numeric value for the beginning of the ScrollBar. Note that the visible size will be set separately. -.setMaximum(int): Determine a numeric value for the end of the ScrollBar. -.setValue(int): Determine the initial location of the Bar on the ScrollBar. This is determined from the Min/Max values. -.setExtent(int): Determine the size of the Bar on the ScrollBar as a fraction of the total size (which is determined from the Min/Max values) as well. Second, create the ScrollBar itself. -setOrientation(ENUM): Determine the orientation of the ScrollBar. Takes VERTICAL_ORIENTATION and HORIZONTAL_ORIENTATION arguments. -setUnitIncrement(int): Determines how much the Scoller moves per click on its end arrows. References to the Min/Max values as well. -setBlockIncrement(int): Determine how many units the ScrollBar moves when the "non-scroller" is clicked. This references the Min/Max values above as well (so if the Min/Max range was 0 to 100, and this was 100, then each click would move the scoller to the opposite end). It would also be impossible to directly click the scroller to a middle location. Note that while in this tutorial both ScrollBars use the same BoundedRangeModel (which causes them to be linked), each ScrollBar individually has these last two settings uniquely set. So while the Scrollers move together (because they use the same Model), using each will cause them to move at different speeds due to these settings being different. ******************************************************/ // Create a DefaultBoundedRangeModel DefaultBoundedRangeModelRecPtr TheBoundedRangeModel = DefaultBoundedRangeModel::create(); TheBoundedRangeModel->setMinimum(10); TheBoundedRangeModel->setMaximum(100); TheBoundedRangeModel->setValue(10); TheBoundedRangeModel->setExtent(20); ScrollBarRecPtr ExampleVerticalScrollBar = ScrollBar::create(); //ExampleScrollPanel->getHorizontalScrollBar() ExampleVerticalScrollBar->setOrientation(ScrollBar::VERTICAL_ORIENTATION); ExampleVerticalScrollBar->setPreferredSize(Vec2f(20,200)); ExampleVerticalScrollBar->setEnabled(false); ExampleVerticalScrollBar->setUnitIncrement(10); ExampleVerticalScrollBar->setBlockIncrement(100); ExampleVerticalScrollBar->setRangeModel(TheBoundedRangeModel); ScrollBarRecPtr ExampleHorizontalScrollBar = ScrollBar::create(); ExampleHorizontalScrollBar->setOrientation(ScrollBar::HORIZONTAL_ORIENTATION); ExampleHorizontalScrollBar->setPreferredSize(Vec2f(400,20)); ExampleHorizontalScrollBar->setRangeModel(TheBoundedRangeModel); // Creates another DefaultBoundedRangeModel to use // for separating the two ScrollBars from each other. // Make sure to comment out the addition of the // previous setModel above. /* DefaultBoundedRangeModel TheBoundedRangeModel2; TheBoundedRangeModel2.setMinimum(0); TheBoundedRangeModel2.setMaximum(100); TheBoundedRangeModel2.setValue(10); TheBoundedRangeModel2.setExtent(20); ExampleHorizontalScrollBar->setModel(&TheBoundedRangeModel2); */ // Create The Main InternalWindow // Create Background to be used with the Main InternalWindow ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create(); MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5)); LayoutRecPtr MainInternalWindowLayout = FlowLayout::create(); InternalWindowRecPtr MainInternalWindow = InternalWindow::create(); MainInternalWindow->pushToChildren(ExampleHorizontalScrollBar); MainInternalWindow->pushToChildren(ExampleVerticalScrollBar); MainInternalWindow->pushToChildren(ExampleScrollPanel); 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); // Create the Drawing Surface UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create(); TutorialDrawingSurface->setGraphics(TutorialGraphics); TutorialDrawingSurface->setEventProducer(TutorialWindow); TutorialDrawingSurface->openWindow(MainInternalWindow); // Create the UI Foreground Object UIForegroundRecPtr TutorialUIForeground = UIForeground::create(); TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface); // Tell the Manager what to manage sceneManager.setRoot(scene); // Add the UI Foreground Object to the Scene ViewportRecPtr TutorialViewport = sceneManager.getWindow()->getPort(0); TutorialViewport->addForeground(TutorialUIForeground); // 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, "27ScrollPanel"); //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(keyPressed, _1)); // Make Torus Node (creates Torus in background of scene) NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16); // Make Main Scene Node and add the Torus NodeRecPtr scene = Node::create(); scene->setCore(Group::create()); scene->addChild(TorusGeometryNode); // Create the Graphics GraphicsRecPtr TutorialGraphics = Graphics2D::create(); // Initialize the LookAndFeelManager to enable default settings LookAndFeelManager::the()->getLookAndFeel()->init(); /****************************************************** Create some Button Components ******************************************************/ ButtonRecPtr ExampleButton1 = Button::create(); ButtonRecPtr ExampleButton2 = Button::create(); ButtonRecPtr ExampleButton3 = Button::create(); ButtonRecPtr ExampleButton4 = Button::create(); /****************************************************** Create Box Layout. Box Layout arranges objects automatically within the Frame, so that the objects are evenly spaced within the Frame. Box Layout also causes all objects to have the same height (if arranged Horizontally) or the same width (if arranged Vertically) using the maximum width of the objects in the Layout. This overrides the specified dimensions of the object, unless the object has a Maximum or Minimum size set. In this case, the object size cannot be changed to greater than the Maximum size, or less than the Minimum size (it will still be changed, however it will not exceed the Max/Min size). You can experiment with this by changing the window size, changing the size of the Buttons as shown in 01Button, editing the Buttons, or adding more Buttons to the view. Note that if the Frame is too small, the objects will appear out of the Frame background. -setOrientation(ENUM): Determine alignment of Layout. Takes VERTICAL_ORIENTATION and HORIZONTAL_ORIENTATION arguments. ******************************************************/ BoxLayoutRecPtr MainInternalWindowLayout = BoxLayout::create(); MainInternalWindowLayout->setOrientation(BoxLayout::VERTICAL_ORIENTATION); //Make the swap to see what happens Between Vertical and Horizontal! //MainInternalWindowLayout->setOrientation(BoxLayout::HORIZONTAL_ORIENTATION); /****************************************************** Edit some of the Button Components. Because of how BoxLayout works, by setting a MaxSize, even though other Buttons within the Layout will be resized, ExampleButton1 cannot be larger than Vec2f(50,50). The default size for all Buttons is Vec2f(100,50) [see DefaultLookAndFeel.cpp], but because ExampleButton2 is larger, each of the other Buttons will be resized to match ExampleButton2's larger size. Experiment by commenting out either line and observing the results. ******************************************************/ ExampleButton1->setPreferredSize(Vec2f(50,50)); ExampleButton1->setMaxSize(Vec2f(50, 50)); //The max size determines how large this button can be even though the BoxLayout says otherwise.(comment out to see the difference) ExampleButton2->setPreferredSize(Vec2f(200,100)); // Create The Main InternalWindow // Create Background to be used with the Main InternalWindow ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create(); MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5)); InternalWindowRecPtr MainInternalWindow = InternalWindow::create(); MainInternalWindow->pushToChildren(ExampleButton1); MainInternalWindow->pushToChildren(ExampleButton2); MainInternalWindow->pushToChildren(ExampleButton3); MainInternalWindow->pushToChildren(ExampleButton4); 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); // Create the Drawing Surface UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create(); TutorialDrawingSurface->setGraphics(TutorialGraphics); TutorialDrawingSurface->setEventProducer(TutorialWindow); TutorialDrawingSurface->openWindow(MainInternalWindow); // Create the UI Foreground Object UIForegroundRecPtr TutorialUIForeground = UIForeground::create(); TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface); // Tell the Manager what to manage sceneManager.setRoot(scene); // Add the UI Foreground Object to the Scene ViewportRecPtr TutorialViewport = sceneManager.getWindow()->getPort(0); TutorialViewport->addForeground(TutorialUIForeground); // 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, "06BoxLayout"); //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(keyPressed, _1)); // Make Torus Node (creates Torus in background of scene) NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16); // Make Main Scene Node and add the Torus NodeRecPtr scene = Node::create(); scene->setCore(Group::create()); scene->addChild(TorusGeometryNode); // Create the Graphics GraphicsRecPtr TutorialGraphics = Graphics2D::create(); // Initialize the LookAndFeelManager to enable default settings LookAndFeelManager::the()->getLookAndFeel()->init(); //Create the nessicary parts for a viewport Matrix TransformMatrix; TransformMatrix.setTranslate(0.0f,0.0f, 0.0f); TransformRecPtr CameraBeaconTransform = Transform::create(); CameraBeaconTransform->setMatrix(TransformMatrix); NodeRecPtr CameraBeaconNode = Node::create(); CameraBeaconNode->setCore(CameraBeaconTransform); // Make Torus Node (creates Torus in background of scene) NodeRecPtr GeometryNode = makeTorus(.5, 2, 32, 32); //Make a light Node NodeRecPtr LightBeaconNode = makeCoredNode<Transform>(); DirectionalLightRecPtr SceneLight = DirectionalLight::create(); SceneLight->setAmbient(Color4f(0.3f,0.3f,0.3f,1.0f)); SceneLight->setDiffuse(Color4f(0.8f,0.8f,0.8f,1.0f)); SceneLight->setSpecular(Color4f(1.0f,1.0f,1.0f,1.0f)); SceneLight->setOn(true); SceneLight->setBeacon(LightBeaconNode); NodeRecPtr LightNode = makeNodeFor(SceneLight); LightNode->addChild(GeometryNode); // Make Main Scene Node and add the Torus NodeRecPtr DefaultRootNode = Node::create(); DefaultRootNode->setCore(Group::create()); DefaultRootNode->addChild(LightNode); DefaultRootNode->addChild(LightBeaconNode); DefaultRootNode->addChild(CameraBeaconNode); //Camera PerspectiveCameraRecPtr DefaultCamera = PerspectiveCamera::create(); DefaultCamera->setBeacon(CameraBeaconNode); DefaultCamera->setFov (osgDegree2Rad(60.f)); DefaultCamera->setNear (0.1f); DefaultCamera->setFar (100.f); //Background GradientBackgroundRecPtr DefaultBackground = GradientBackground::create(); DefaultBackground->addLine(Color3f(0.0f,0.0f,0.0f), 0.0f); DefaultBackground->addLine(Color3f(0.0f,0.0f,1.0f), 1.0f); //Viewport ViewportRecPtr DefaultViewport = Viewport::create(); DefaultViewport->setCamera (DefaultCamera); DefaultViewport->setRoot (DefaultRootNode); DefaultViewport->setSize (0.0f,0.0f, 1.0f,1.0f); DefaultViewport->setBackground (DefaultBackground); //GL Viewport Component LineBorderRecPtr TheGLViewportBorder = LineBorder::create(); TheGLViewportBorder->setColor(Color4f(1.0,0.0,0.0,1.0)); TheGLViewportBorder->setWidth(3.0); GLViewportRecPtr TheGLViewport = GLViewport::create(); TheGLViewport->setPort(DefaultViewport); TheGLViewport->setPreferredSize(Vec2f(400.0f,400.0f)); TheGLViewport->setBorders(TheGLViewportBorder); TheGLViewport->lookAt(Pnt3f(0.0f,0.0f,10.0f), //From Pnt3f(0.0f,0.0f,0.0f), //At Vec3f(0.0f,1.0f,0.0f)); //Up ButtonRecPtr ExampleButton = Button::create(); ExampleButton->setText("Example"); // Create The Main InternalWindow // Create Background to be used with the Main InternalWindow ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create(); MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5)); InternalWindowRecPtr MainInternalWindow = InternalWindow::create(); LayoutRecPtr MainInternalWindowLayout = FlowLayout::create(); MainInternalWindow->pushToChildren(TheGLViewport); MainInternalWindow->pushToChildren(ExampleButton); MainInternalWindow->setLayout(MainInternalWindowLayout); MainInternalWindow->setBackgrounds(MainInternalWindowBackground); MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f)); MainInternalWindow->setScalingInDrawingSurface(Vec2f(0.95f,0.95f)); MainInternalWindow->setDrawTitlebar(false); MainInternalWindow->setResizable(false); // Create the Drawing Surface UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create(); TutorialDrawingSurface->setGraphics(TutorialGraphics); TutorialDrawingSurface->setEventProducer(TutorialWindow); TutorialDrawingSurface->openWindow(MainInternalWindow); // Create the UI Foreground Object UIForegroundRecPtr TutorialUIForeground = UIForeground::create(); TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface); // Tell the Manager what to manage sceneManager.setRoot(scene); // Add the UI Foreground Object to the Scene ViewportRecPtr TutorialViewport = sceneManager.getWindow()->getPort(0); TutorialViewport->addForeground(TutorialUIForeground); //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, "41GLViewportComponent"); //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); // Make Torus Node (creates Torus in background of scene) NodeRefPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16); // Make Main Scene Node and add the Torus NodeRefPtr scene = Node::create(); scene->setCore(Group::create()); scene->addChild(TorusGeometryNode); // Create the Graphics GraphicsRefPtr TutorialGraphics = Graphics2D::create(); // Initialize the LookAndFeelManager to enable default settings LookAndFeelManager::the()->getLookAndFeel()->init(); TextEditorRefPtr theTextEditor = TextEditor::create(); theTextEditor->setPreferredSize(Vec2f(1000,700)); theTextEditor->setIsSplit(false); theTextEditor->setClipboardVisible(false); //Toggle Button for clipboard ToggleButtonRefPtr ClipboardButton = ToggleButton::create(); ClipboardButton->setPreferredSize(Vec2f(80, 40)); ClipboardButton->setText("Clipboard"); ClipboardButton->connectButtonSelected(boost::bind(handleClipboardSelected, _1, theTextEditor.get())); ClipboardButton->connectButtonDeselected(boost::bind(handleClipboardDeselected, _1, theTextEditor.get())); //Toggle Button for split panel ToggleButtonRefPtr SplitButton = ToggleButton::create(); SplitButton->setPreferredSize(Vec2f(80, 40)); SplitButton->setText("Split"); SplitButton->connectButtonSelected(boost::bind(handleSplitSelected, _1, theTextEditor.get())); SplitButton->connectButtonDeselected(boost::bind(handleSplitDeselected, _1, theTextEditor.get())); ButtonRefPtr LoadButton = Button::create(); LoadButton->setMinSize(Vec2f(50, 25)); LoadButton->setMaxSize(Vec2f(200, 100)); LoadButton->setPreferredSize(Vec2f(80, 40)); LoadButton->setToolTipText("Click to open a file browser window"); LoadButton->setText("Load File"); LoadButton->connectActionPerformed(boost::bind(handleLoadButtonAction, _1, TutorialWindow.get(), theTextEditor.get())); ButtonRefPtr SaveButton = Button::create(); SaveButton->setMinSize(Vec2f(50, 25)); SaveButton->setMaxSize(Vec2f(200, 100)); SaveButton->setPreferredSize(Vec2f(80, 40)); SaveButton->setToolTipText("Click to save the currently opened file"); SaveButton->setText("Save File"); SaveButton->connectActionPerformed(boost::bind(handleSaveButtonAction, _1, TutorialWindow.get(),theTextEditor.get())); //Button Panel LayoutRefPtr ButtonPanelLayout = FlowLayout::create(); PanelRecPtr ButtonPanel = Panel::createEmpty(); ButtonPanel->setPreferredSize(Vec2f(300, 300)); ButtonPanel->setLayout(ButtonPanelLayout); ButtonPanel->pushToChildren(LoadButton); ButtonPanel->pushToChildren(SaveButton); ButtonPanel->pushToChildren(SplitButton); ButtonPanel->pushToChildren(ClipboardButton); // 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)); LayoutRefPtr MainInternalWindowLayout = FlowLayout::create(); InternalWindowRefPtr MainInternalWindow = InternalWindow::create(); //MainInternalWindow->pushToChildren(TextAreaScrollPanel); MainInternalWindow->pushToChildren(theTextEditor); MainInternalWindow->pushToChildren(ButtonPanel); MainInternalWindow->setLayout(MainInternalWindowLayout); MainInternalWindow->setBackgrounds(MainInternalWindowBackground); MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f)); MainInternalWindow->setScalingInDrawingSurface(Vec2f(0.95f,0.95f)); //MainInternalWindow->setDrawTitlebar(true); //MainInternalWindow->setResizable(true); // 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); sceneManager.setRoot(scene); // Add the UI Foreground Object to the Scene ViewportRefPtr TutorialViewport = sceneManager.getWindow()->getPort(0); TutorialViewport->addForeground(TutorialUIForeground); // Show the whole Scene sceneManager.showAll(); //Open Window Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.95f); Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5); TutorialWindow->openWindow(WinPos, WinSize, "06Editor"); TutorialWindow->connectKeyTyped(boost::bind(keyTyped, _1, theTextEditor.get())); commitChanges(); //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(keyPressed, _1)); // Make Torus Node (creates Torus in background of scene) NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16); // Make Main Scene Node and add the Torus NodeRecPtr scene = Node::create(); scene->setCore(Group::create()); scene->addChild(TorusGeometryNode); // Create the Graphics GraphicsRecPtr TutorialGraphics = 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. ******************************************************/ ButtonRecPtr ExampleButton = Button::create(); UIFontRecPtr ExampleFont = UIFont::create(); ExampleFont->setSize(16); ExampleButton->setMinSize(Vec2f(50, 25)); ExampleButton->setMaxSize(Vec2f(200, 100)); ExampleButton->setPreferredSize(Vec2f(100, 50)); ExampleButton->setToolTipText("Button 1 ToolTip"); ExampleButton->setText("Button 1"); 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(1.0,0.0)); /****************************************************** Create a ToggleButton and determine its characteristics. ToggleButton inherits off of Button, so all characteristsics used above can be used with ToggleButtons as well. The only difference is that when pressed, ToggleButton remains pressed until pressed again. -setSelected(bool): Determine whether the ToggleButton is Selected (true) or deselected (false). ******************************************************/ ToggleButtonRecPtr ExampleToggleButton = ToggleButton::create(); ExampleToggleButton->setSelected(false); ExampleToggleButton->setText("ToggleMe"); ExampleToggleButton->setToolTipText("Toggle Button ToolTip"); // Create Background to be used with the MainInternalWindow ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create(); MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5)); // Create The Internal Window InternalWindowRecPtr MainInternalWindow = InternalWindow::create(); LayoutRecPtr MainInternalWindowLayout = FlowLayout::create(); // Assign the Button to the MainInternalWindow so it will be displayed // when the view is rendered. MainInternalWindow->pushToChildren(ExampleButton); MainInternalWindow->setLayout(MainInternalWindowLayout); MainInternalWindow->setBackgrounds(MainInternalWindowBackground); MainInternalWindow->setPosition(Pnt2f(50,50)); MainInternalWindow->setPreferredSize(Vec2f(300,300)); MainInternalWindow->setTitle(std::string("Internal Window 1")); // Create The Internal Window InternalWindowRecPtr MainInternalWindow2 = InternalWindow::create(); LayoutRecPtr MainInternalWindowLayout2 = FlowLayout::create(); // Assign the Button to the MainInternalWindow so it will be displayed // when the view is rendered. MainInternalWindow2->pushToChildren(ExampleToggleButton); MainInternalWindow2->setLayout(MainInternalWindowLayout2); MainInternalWindow2->setBackgrounds(MainInternalWindowBackground); MainInternalWindow2->setPosition(Pnt2f(150,150)); MainInternalWindow2->setPreferredSize(Vec2f(300,300)); MainInternalWindow2->setTitle(std::string("Allways on top window")); MainInternalWindow2->setIconable(false); MainInternalWindow2->setAllwaysOnTop(true); // Create the Drawing Surface UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create(); TutorialDrawingSurface->setGraphics(TutorialGraphics); TutorialDrawingSurface->setEventProducer(TutorialWindow); TutorialDrawingSurface->openWindow(MainInternalWindow); TutorialDrawingSurface->openWindow(MainInternalWindow2); // Create the UI Foreground Object UIForegroundRecPtr TutorialUIForeground = UIForeground::create(); TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface); // Tell the Manager what to manage sceneManager.setRoot(scene); // Add the UI Foreground Object to the Scene ViewportRecPtr TutorialViewport = sceneManager.getWindow()->getPort(0); TutorialViewport->addForeground(TutorialUIForeground); // 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, "37InternalWindow"); //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 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())); //Torus Node NodeUnrecPtr TorusGeometryNode = makeTorus(.5, 2, 32, 32); //Make Torus Node NodeUnrecPtr TorusNode = Node::create(); TransformUnrecPtr TorusNodeTrans; TorusNodeTrans = Transform::create(); TorusNode->setCore(TorusNodeTrans); TorusNode->addChild(TorusGeometryNode); //Make Main Scene Node NodeUnrecPtr scene = Node::create(); ComponentTransformUnrecPtr Trans; Trans = ComponentTransform::create(); scene->setCore(Trans); // add the torus as a child scene->addChild(TorusNode); //Make a gradient Background GradientBackgroundUnrecPtr TutorialBackground = GradientBackground::create(); TutorialBackground->addLine(Color3f(1.0,0.0,0.0),0.0); TutorialBackground->addLine(Color3f(0.0,1.0,0.0),0.5); TutorialBackground->addLine(Color3f(0.0,0.0,1.0),1.0); setName(TutorialBackground, std::string("TutorialGradientBackground")); AnimationUnrecPtr TheAnimation = setupAnimation(TutorialBackground); TheAnimation->attachUpdateProducer(TutorialWindow); TheAnimation->start(); // tell the manager what to manage sceneManager.setRoot (scene); sceneManager.getWindow()->getPort(0)->setBackground(TutorialBackground); //Create the Documentation 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, "03MFieldAnimation"); //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(keyPressed, _1)); // Make Torus Node (creates Torus in background of scene) NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16); // Make Main Scene Node and add the Torus NodeRecPtr scene = Node::create(); scene->setCore(Group::create()); scene->addChild(TorusGeometryNode); // Create the Graphics GraphicsRecPtr TutorialGraphics = Graphics2D::create(); // Initialize the LookAndFeelManager to enable default settings LookAndFeelManager::the()->getLookAndFeel()->init(); /****************************************************** Create BorderLayout and some BorderLayoutConstraints to be used to set up CardLayout. ******************************************************/ BorderLayoutRecPtr MainInternalWindowLayout = BorderLayout::create(); BorderLayoutConstraintsRecPtr ExampleButton1Constraints = BorderLayoutConstraints::create(); BorderLayoutConstraintsRecPtr ExampleButton2Constraints = BorderLayoutConstraints::create(); BorderLayoutConstraintsRecPtr ExampleButton7Constraints = BorderLayoutConstraints::create(); BorderLayoutConstraintsRecPtr ExampleButton8Constraints = BorderLayoutConstraints::create(); BorderLayoutConstraintsRecPtr ExampleCardPanelConstraints = BorderLayoutConstraints::create(); ExampleButton1Constraints->setRegion(BorderLayoutConstraints::BORDER_EAST); ExampleButton2Constraints->setRegion(BorderLayoutConstraints::BORDER_WEST); ExampleButton7Constraints->setRegion(BorderLayoutConstraints::BORDER_NORTH); ExampleButton8Constraints->setRegion(BorderLayoutConstraints::BORDER_SOUTH); ExampleCardPanelConstraints->setRegion(BorderLayoutConstraints::BORDER_CENTER); /****************************************************** Create CardLayout. CardLayout shows a single Component at a time, meaning it is not exactly practical to use it alone for a Layout. This tutorial uses the BorderLayout to include a Panel in the Center Region, and within that Panel using a CardLayout. A single card is displayed at one time within a ComponentContainer using CardLayout. CardLayout has four functions: next, previous, first, and last. ->next(CardContainerName): Causes CardLayout to display the next card. ->previous(CardContainerName): Causes CardLayout to display the previous card. ->first(CardContainerName): Causes CardLayout to display the first card. ->last(CardContainerName): Causes CardLayout to display the last card. These are most useful when combined with Action, as shown at the top of this Tutorial, to assign actions to the Buttons or Components to allow the user to cycle through the Card Layout and view different ExampleCards. Note that CardContainerName is the name of the ComponentContainer which is using the CardLayout, while the begin/endEditCP is performed on the CardLayout itself. ******************************************************/ CardLayoutRecPtr ExampleCardLayout = CardLayout::create(); PanelRecPtr ExampleCardPanel = Panel::create(); /****************************************************** Create Button Components to be used with CardLayout to allow for interactivity. ******************************************************/ ButtonRecPtr ExampleButton1 = Button::create(); ButtonRecPtr ExampleButton2 = Button::create(); ButtonRecPtr ExampleButton3 = Button::create(); ButtonRecPtr ExampleButton4 = Button::create(); ButtonRecPtr ExampleButton5 = Button::create(); ButtonRecPtr ExampleButton6 = Button::create(); ButtonRecPtr ExampleButton7 = Button::create(); ButtonRecPtr ExampleButton8 = Button::create(); ExampleButton1->setText("Next Card"); ExampleButton1->setConstraints(ExampleButton1Constraints); // Add Action ExampleButton1->connectActionPerformed(boost::bind(handleNextCardAction, _1, ExampleCardLayout.get(), ExampleCardPanel.get())); ExampleButton2->setText("Previous Card"); ExampleButton2->setConstraints(ExampleButton2Constraints); // Add Action ExampleButton2->connectActionPerformed(boost::bind(handleBackCardAction, _1, ExampleCardLayout.get(), ExampleCardPanel.get())); ExampleButton3->setText("This"); ExampleButton4->setText("is"); ExampleButton5->setText("Card"); ExampleButton6->setText("Layout"); ExampleButton7->setText("First Card"); ExampleButton7->setConstraints(ExampleButton7Constraints); // Add Action ExampleButton7->connectActionPerformed(boost::bind(handleFirstCardAction, _1, ExampleCardLayout.get(), ExampleCardPanel.get())); ExampleButton8->setText("Last Card"); ExampleButton8->setConstraints(ExampleButton8Constraints); // Add Action ExampleButton8->connectActionPerformed(boost::bind(handleLastCardAction, _1, ExampleCardLayout.get(), ExampleCardPanel.get())); ExampleCardPanel->setLayout(ExampleCardLayout); ExampleCardPanel->pushToChildren(ExampleButton3); ExampleCardPanel->pushToChildren(ExampleButton4); ExampleCardPanel->pushToChildren(ExampleButton5); ExampleCardPanel->pushToChildren(ExampleButton6); ExampleCardPanel->setConstraints(ExampleCardPanelConstraints); // Create The Main InternalWindow // Create Background to be used with the Main InternalWindow ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create(); MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5)); InternalWindowRecPtr MainInternalWindow = InternalWindow::create(); MainInternalWindow->pushToChildren(ExampleButton1); MainInternalWindow->pushToChildren(ExampleButton2); MainInternalWindow->pushToChildren(ExampleButton7); MainInternalWindow->pushToChildren(ExampleButton8); MainInternalWindow->pushToChildren(ExampleCardPanel); 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); // Create the Drawing Surface UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create(); TutorialDrawingSurface->setGraphics(TutorialGraphics); TutorialDrawingSurface->setEventProducer(TutorialWindow); TutorialDrawingSurface->openWindow(MainInternalWindow); // Create the UI Foreground Object UIForegroundRecPtr TutorialUIForeground = UIForeground::create(); TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface); // Tell the Manager what to manage sceneManager.setRoot(scene); // Add the UI Foreground Object to the Scene ViewportRecPtr TutorialViewport = sceneManager.getWindow()->getPort(0); TutorialViewport->addForeground(TutorialUIForeground); //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, "11CardLayout"); //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(keyPressed, _1)); // Make Torus Node (creates Torus in background of scene) NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16); // Make Main Scene Node and add the Torus NodeRecPtr scene = Node::create(); scene->setCore(Group::create()); scene->addChild(TorusGeometryNode); // Create the Graphics GraphicsRecPtr TutorialGraphics = Graphics2D::create(); // Initialize the LookAndFeelManager to enable default settings LookAndFeelManager::the()->getLookAndFeel()->init(); // Create a simple Font to be used with the ExampleTextArea UIFontRecPtr ExampleFont = UIFont::create(); ExampleFont->setSize(16); /****************************************************** Create and edit the TextArea and determine its characteristics. A TextArea is a component that allows you to enter text into the box via keyboard input. You can select text by using your mouse or pressing shift and the left and right arrow keys. The only difference between a TextArea and TextField is that a TextArea can have multiple lines of text within it. -setTextColor(Color4f): Determine color of text within TextArea. -setSelectionBoxColor(Color4f): Determine the color that highlighting around the selected text appears. -setSelectionTextColor(Color4f): Determine the color the selected text appears. -setText("TextToBeDisplayed"): Determine initial text within TextArea. -setFont(FontName): Determine the Font used within TextArea -setSelectionStart(StartCharacterNumber): Determine the character which the selection will initially start after. -setSelectionEnd(EndCharacterNumber): Determine the character which the selection will end before. -setCaretPosition(Location): Determine the location of the Caret within the TextArea. Note: this does not do too much currently because the only way to cause the TextArea to gain focus is to click within it, causing the Caret to move. ******************************************************/ // Create a TextArea component TextAreaRecPtr ExampleTextArea = TextArea::create(); ExampleTextArea->setPreferredSize(Vec2f(300, 200)); ExampleTextArea->setMinSize(Vec2f(300, 200)); ExampleTextArea->setTextColor(Color4f(0.0, 0.0, 0.0, 1.0)); ExampleTextArea->setSelectionBoxColor(Color4f(0.0, 0.0, 1.0, 1.0)); ExampleTextArea->setSelectionTextColor(Color4f(1.0, 1.0, 1.0, 1.0)); // Determine the font and initial text ExampleTextArea->setText("What"); ExampleTextArea->setFont(ExampleFont); // This will select the "a" from above ExampleTextArea->setSelectionStart(2); ExampleTextArea->setSelectionEnd(3); ExampleTextArea->setCaretPosition(2); //ExampleTextArea->setLineWrap(false); // Create a ScrollPanel ScrollPanelRecPtr TextAreaScrollPanel = ScrollPanel::create(); TextAreaScrollPanel->setPreferredSize(Vec2f(200,200)); TextAreaScrollPanel->setHorizontalResizePolicy(ScrollPanel::RESIZE_TO_VIEW); // Add the TextArea to the ScrollPanel so it is displayed TextAreaScrollPanel->setViewComponent(ExampleTextArea); // Create The Main InternalWindow // Create Background to be used with the Main InternalWindow ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create(); MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5)); LayoutRecPtr MainInternalWindowLayout = FlowLayout::create(); InternalWindowRecPtr MainInternalWindow = InternalWindow::create(); MainInternalWindow->pushToChildren(TextAreaScrollPanel); 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); // Create the Drawing Surface UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create(); TutorialDrawingSurface->setGraphics(TutorialGraphics); TutorialDrawingSurface->setEventProducer(TutorialWindow); TutorialDrawingSurface->openWindow(MainInternalWindow); // Create the UI Foreground Object UIForegroundRecPtr TutorialUIForeground = UIForeground::create(); TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface); // Tell the Manager what to manage sceneManager.setRoot(scene); // Add the UI Foreground Object to the Scene ViewportRecPtr TutorialViewport = sceneManager.getWindow()->getPort(0); TutorialViewport->addForeground(TutorialUIForeground); // 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, "22TextArea"); //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(keyPressed, _1)); // Make Torus Node (creates Torus in background of scene) NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16); // Make Main Scene Node and add the Torus NodeRecPtr scene = Node::create(); scene->setCore(Group::create()); scene->addChild(TorusGeometryNode); // Create the Graphics GraphicsRecPtr TutorialGraphics = Graphics2D::create(); // Initialize the LookAndFeelManager to enable default settings LookAndFeelManager::the()->getLookAndFeel()->init(); /****************************************************** Create and edit a CheckboxButton. Note: the only function call shown specific to CheckboxButton is setSelected. In DefaultLookAndFeel, the options for changing the style of the CheckBox are shown. CheckboxButton also inherits off Button so all features of Button may be used. -setSelected(bool): Determines if the CheckboxButton is checked(true) or not checked(false). ******************************************************/ CheckboxButtonRecPtr ExampleCheckboxButton = CheckboxButton::create(); ExampleCheckboxButton->setMinSize(Vec2f(50, 25)); ExampleCheckboxButton->setMaxSize(Vec2f(300, 100)); ExampleCheckboxButton->setPreferredSize(Vec2f(200, 50)); ExampleCheckboxButton->setEnabled(true); ExampleCheckboxButton->setText("Checkbox Button"); ExampleCheckboxButton->setAlignment(Vec2f(0.5,0.5)); ExampleCheckboxButton->setSelected(true); // Create The Main InternalWindow // Create Background to be used with the Main InternalWindow ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create(); MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5)); LayoutRecPtr MainInternalWindowLayout = FlowLayout::create(); InternalWindowRecPtr MainInternalWindow = InternalWindow::create(); MainInternalWindow->pushToChildren(ExampleCheckboxButton); 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); // Create the Drawing Surface UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create(); TutorialDrawingSurface->setGraphics(TutorialGraphics); TutorialDrawingSurface->setEventProducer(TutorialWindow); TutorialDrawingSurface->openWindow(MainInternalWindow); // Create the UI Foreground Object UIForegroundRecPtr TutorialUIForeground = UIForeground::create(); TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface); // Tell the Manager what to manage sceneManager.setRoot(scene); // Add the UI Foreground Object to the Scene ViewportRecPtr TutorialViewport = sceneManager.getWindow()->getPort(0); TutorialViewport->addForeground(TutorialUIForeground); // 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, "13CheckboxButton"); //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)); // Make Torus Node (creates Torus in background of scene) NodeRefPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16); // Make Main Scene Node and add the Torus NodeRefPtr scene = OSG::Node::create(); scene->setCore(OSG::Group::create()); scene->addChild(TorusGeometryNode); // Create the Graphics GraphicsRefPtr TutorialGraphics = OSG::Graphics2D::create(); // Initialize the LookAndFeelManager to enable default settings LookAndFeelManager::the()->getLookAndFeel()->init(); ButtonRefPtr ExampleButton = OSG::Button::create(); ExampleButton->setMinSize(Vec2f(50, 25)); ExampleButton->setMaxSize(Vec2f(200, 100)); ExampleButton->setPreferredSize(Vec2f(100, 50)); ExampleButton->setText("Button 1"); // 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 ExampleButton->connectActionPerformed(boost::bind(actionPerformed, _1)); //Toggle Button ToggleButtonRefPtr ExampleToggleButton = OSG::ToggleButton::create(); ExampleToggleButton->setSelected(false); ExampleToggleButton->setText("ToggleMe"); //Text Field TextFieldRefPtr ExampleTextField = OSG::TextField::create(); //Password Field PasswordFieldRefPtr ExamplePasswordField = OSG::PasswordField::create(); LayoutRefPtr MainLayout = OSG::FlowLayout::create(); //Panel PanelRecPtr ExamplePanel = Panel::create(); ExamplePanel->setPreferredSize(Vec2f(200.0f,200.0f)); ExamplePanel->setLayout(MainLayout); ExamplePanel->pushToChildren(ExampleTextField); ExamplePanel->pushToChildren(ExamplePasswordField); //Text Field 2 TextFieldRefPtr ExampleTextField2 = OSG::TextField::create(); // Create The Main InternalWindow // Create Background to be used with the Main InternalWindow ColorLayerRefPtr MainInternalWindowBackground = OSG::ColorLayer::create(); MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5)); InternalWindowRefPtr MainInternalWindow = OSG::InternalWindow::create(); MainInternalWindow->pushToChildren(ExampleButton); MainInternalWindow->pushToChildren(ExampleToggleButton); MainInternalWindow->pushToChildren(ExamplePanel); MainInternalWindow->pushToChildren(ExampleTextField2); MainInternalWindow->setLayout(MainLayout); MainInternalWindow->setBackgrounds(MainInternalWindowBackground); MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f)); MainInternalWindow->setScalingInDrawingSurface(Vec2f(0.5f,0.5f)); MainInternalWindow->setDrawTitlebar(false); MainInternalWindow->setResizable(false); // Create the Drawing Surface UIDrawingSurfaceRefPtr TutorialDrawingSurface = UIDrawingSurface::create(); TutorialDrawingSurface->setGraphics(TutorialGraphics); TutorialDrawingSurface->setEventProducer(TutorialWindow); TutorialDrawingSurface->openWindow(MainInternalWindow); // Create the UI Foreground Object UIForegroundRefPtr TutorialUIForeground = OSG::UIForeground::create(); TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface); sceneManager.setRoot(scene); // Add the UI Foreground Object to the Scene ViewportRefPtr TutorialViewport = sceneManager.getWindow()->getPort(0); TutorialViewport->addForeground(TutorialUIForeground); //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.5f); TutorialWindow->openWindow(WinPos, WinSize, "54FocusProgession"); commitChanges(); //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(keyPressed, _1)); // Make Torus Node (creates Torus in background of scene) NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16); // Make Main Scene Node and add the Torus NodeRecPtr scene = Node::create(); scene->setCore(Group::create()); scene->addChild(TorusGeometryNode); // Create the Graphics GraphicsRecPtr TutorialGraphics = Graphics2D::create(); // Initialize the LookAndFeelManager to enable default settings LookAndFeelManager::the()->getLookAndFeel()->init(); // Create a simple Font to be used with the TextField UIFontRecPtr sampleFont = UIFont::create(); sampleFont->setSize(16); /****************************************************** Create and edit the TextField. A TextField is a Component which allows a single line of text to be displayed. Text can be entered via the keyboard, and selected with arrow keys or the Mouse. -setTextColor(Color4f): Determine the Text Color. setSelectionBoxColor(Color4f): Determine the Color of highlighting around selected Text. -setSelectionTextColor(Color4f): Determine the Color of selected Text. -setText("TextToBeDisplayed"): Determine initial Text within TextField. -setFont(FontName): Determine the Font used within TextField. -setSelectionStart(StartCharacterNumber): Determine the character with which the selection will initially start. -setSelectionEnd(EndCharacterNumber): Determine the character which the selection ends before. -setAlignment(float): Determine the alignment of the text. The float is a percentage is from the top of the text [0.0-1.0]. Note: be sure to visually verify this, as due to font size and line size this does not always place it exactly at the percentage point. ******************************************************/ // Create a TextField component TextFieldRecPtr ExampleTextField = TextField::create(); ExampleTextField->setPreferredSize(Vec2f(100, 50)); ExampleTextField->setTextColor(Color4f(0.0, 0.0, 0.0, 1.0)); ExampleTextField->setSelectionBoxColor(Color4f(0.0, 0.0, 1.0, 1.0)); ExampleTextField->setSelectionTextColor(Color4f(1.0, 1.0, 1.0, 1.0)); ExampleTextField->setText("What"); ExampleTextField->setFont(sampleFont); // The next two functions will select the "a" from above ExampleTextField->setSelectionStart(2); ExampleTextField->setSelectionEnd(3); ExampleTextField->setAlignment(Vec2f(0.0,0.5)); // Create another TextField Component TextFieldRecPtr ExampleTextField2 = TextField::create(); ExampleTextField2->setText(""); ExampleTextField2->setEmptyDescText("Write in me, please"); ExampleTextField2->setPreferredSize(Vec2f(200.0f,ExampleTextField2->getPreferredSize().y())); // Create The Main InternalWindow // Create Background to be used with the Main InternalWindow ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create(); MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5)); LayoutRecPtr MainInternalWindowLayout = FlowLayout::create(); InternalWindowRecPtr MainInternalWindow = InternalWindow::create(); MainInternalWindow->pushToChildren(ExampleTextField); MainInternalWindow->pushToChildren(ExampleTextField2); 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); // Create the Drawing Surface UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create(); TutorialDrawingSurface->setGraphics(TutorialGraphics); TutorialDrawingSurface->setEventProducer(TutorialWindow); TutorialDrawingSurface->openWindow(MainInternalWindow); // Create the UI Foreground Object UIForegroundRecPtr TutorialUIForeground = UIForeground::create(); TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface); // Tell the Manager what to manage sceneManager.setRoot(scene); // Add the UI Foreground Object to the Scene ViewportRecPtr TutorialViewport = sceneManager.getWindow()->getPort(0); TutorialViewport->addForeground(TutorialUIForeground); // 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, "16TextField"); //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)); // Make Torus Node (creates Torus in background of scene) NodeRefPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16); // Make Main Scene Node and add the Torus NodeRefPtr scene = OSG::Node::create(); scene->setCore(OSG::Group::create()); scene->addChild(TorusGeometryNode); // Create the Graphics GraphicsRefPtr TutorialGraphics = OSG::Graphics2D::create(); // Initialize the LookAndFeelManager to enable default settings LookAndFeelManager::the()->getLookAndFeel()->init(); //Background SolidBackgroundRefPtr TutorialBackground = SolidBackground::create(); TutorialBackground->setColor(Color3f(1.0,0.0,0.0)); UndoManagerPtr TheUndoManager = UndoManager::create(); CommandManagerPtr TheCommandManager = CommandManager::create(TheUndoManager); //UndoList DefaultListModelRecPtr UndoRedoListModel = DefaultListModel::create(); UndoRedoListModel->pushBack(boost::any(std::string("Top"))); ListRecPtr UndoRedoList = List::create(); UndoRedoList->setPreferredSize(Vec2f(250, 300)); UndoRedoList->setOrientation(List::VERTICAL_ORIENTATION); UndoRedoList->setModel(UndoRedoListModel); UndoRedoList->getSelectionModel()->connectSelectionChanged(boost::bind(&handleUndoRedoListSelectionChanged, _1, TheUndoManager)); ButtonRecPtr UndoButton = OSG::Button::create(); UndoButton->setText("Undo"); UndoButton->setEnabled(false); UndoButton->connectActionPerformed(boost::bind(&handleUndoButtonAction, _1, TheUndoManager)); ButtonRecPtr RedoButton = OSG::Button::create(); RedoButton->setText("Redo"); RedoButton->setEnabled(false); RedoButton->connectActionPerformed(boost::bind(&handleRedoButtonActionPerformed, _1, TheUndoManager)); TheUndoManager->connectStateChanged(boost::bind(&handleUndoManagerStateChanged, _1, UndoButton.get(), RedoButton.get(), UndoRedoListModel.get(), TheUndoManager)); // Create a ScrollPanel for easier viewing of the List (see 27ScrollPanel) ScrollPanelRefPtr UndoRedoScrollPanel = ScrollPanel::create(); UndoRedoScrollPanel->setPreferredSize(Vec2f(200,200)); UndoRedoScrollPanel->setHorizontalResizePolicy(ScrollPanel::RESIZE_TO_VIEW); UndoRedoScrollPanel->setViewComponent(UndoRedoList); //Edited Label LabelRecPtr EditedLabel = Label::create(); EditedLabel->setText("Can be edited"); EditedLabel->setPreferredSize(Vec2f(100.0f,18.0f)); //Editor Field LabelRecPtr TheTextEditorLabel = Label::create(); TheTextEditorLabel->setText("Text"); TheTextEditorLabel->setPreferredSize(Vec2f(100.0f, 20.0f)); FieldEditorComponentRefPtr TheTextEditor = FieldEditorFactory::the()->createDefaultEditor(EditedLabel, Label::TextFieldId, TheCommandManager); TheTextEditor->setPreferredSize(Vec2f(100.0f, 20.0f)); LabelRecPtr ThePreferredSizeEditorLabel = Label::create(); ThePreferredSizeEditorLabel->setText("PreferredSize"); ThePreferredSizeEditorLabel->setPreferredSize(Vec2f(100.0f, 20.0f)); FieldEditorComponentRefPtr ThePreferredSizeEditor = FieldEditorFactory::the()->createDefaultEditor(EditedLabel, Label::PreferredSizeFieldId, TheCommandManager); ThePreferredSizeEditor->setPreferredSize(Vec2f(150.0f, 20.0f)); //Editing Panel LayoutRefPtr EditorPanelLayout = OSG::FlowLayout::create(); PanelRecPtr EditorPanel = Panel::create(); EditorPanel->setPreferredSize(Vec2f(200.0f,200.0f)); EditorPanel->pushToChildren(TheTextEditorLabel); EditorPanel->pushToChildren(TheTextEditor); EditorPanel->pushToChildren(ThePreferredSizeEditorLabel); EditorPanel->pushToChildren(ThePreferredSizeEditor); EditorPanel->setLayout(EditorPanelLayout); //Undo Panel LabelRecPtr UndoPanelLabel = Label::create(); UndoPanelLabel->setText("Undo Panel"); UndoPanelLabel->setPreferredSize(Vec2f(100.0f, 20.0f)); LayoutRefPtr UndoPanelLayout = OSG::FlowLayout::create(); PanelRecPtr UndoPanel = Panel::create(); UndoPanel->setPreferredSize(Vec2f(300.0f,300.0f)); UndoPanel->pushToChildren(UndoPanelLabel); UndoPanel->pushToChildren(UndoRedoScrollPanel); UndoPanel->pushToChildren(UndoButton); UndoPanel->pushToChildren(RedoButton); UndoPanel->setLayout(UndoPanelLayout); // Create The Main InternalWindow // Create Background to be used with the Main InternalWindow ColorLayerRefPtr MainInternalWindowBackground = OSG::ColorLayer::create(); MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5)); InternalWindowRefPtr MainInternalWindow = OSG::InternalWindow::create(); LayoutRefPtr MainInternalWindowLayout = OSG::FlowLayout::create(); MainInternalWindow->pushToChildren(EditedLabel); MainInternalWindow->pushToChildren(EditorPanel); MainInternalWindow->pushToChildren(UndoPanel); MainInternalWindow->setLayout(MainInternalWindowLayout); MainInternalWindow->setBackgrounds(MainInternalWindowBackground); MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f)); MainInternalWindow->setScalingInDrawingSurface(Vec2f(0.95f,0.95f)); MainInternalWindow->setDrawTitlebar(false); MainInternalWindow->setResizable(false); // Create the Drawing Surface UIDrawingSurfaceRefPtr TutorialDrawingSurface = UIDrawingSurface::create(); TutorialDrawingSurface->setGraphics(TutorialGraphics); TutorialDrawingSurface->setEventProducer(TutorialWindow); TutorialDrawingSurface->openWindow(MainInternalWindow); // Create the UI Foreground Object UIForegroundRefPtr TutorialUIForeground = OSG::UIForeground::create(); TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface); // Tell the Manager what to manage sceneManager.setWindow(TutorialWindow); sceneManager.setRoot(scene); // Add the UI Foreground Object to the Scene ViewportRefPtr TutorialViewport = sceneManager.getWindow()->getPort(0); TutorialViewport->addForeground(TutorialUIForeground); TutorialViewport->setBackground(TutorialBackground); // 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, "02GenericFieldEditor"); //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(keyPressed, _1)); // Make Torus Node (creates Torus in background of scene) NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16); // Make Main Scene Node and add the Torus NodeRecPtr scene = Node::create(); scene->setCore(Group::create()); scene->addChild(TorusGeometryNode); // Create the Graphics GraphicsRecPtr TutorialGraphics = Graphics2D::create(); // Initialize the LookAndFeelManager to enable default settings LookAndFeelManager::the()->getLookAndFeel()->init(); /****************************************************** Create a RotatedComponent. -setAngle(Angle, in radians): Determine the angle the Component initially is rotated. -setInternalComponent(Component): Determine what Component will be rotated. -setResizePolicy(RotatedComponent::ENUM): Takes NO_RESIZING, RESIZE_TO_MIN, or RESIZE_TO_MAX arguments. ******************************************************/ RotatedComponentRecPtr TheRotatedComponent = RotatedComponent::create(); // Define PI Real32 PI(3.14159); TheRotatedComponent->setAngle(PI/4); ComponentRecPtr InnerPanel = createPanel(); TheRotatedComponent->setInternalComponent(InnerPanel); TheRotatedComponent->setResizePolicy(RotatedComponent::RESIZE_TO_MIN); /****************************************************** Create a ToggleButton which can be used to start and stop the Button from rotating. Note: due to the way FlowLayout works you will notice that this ToggleButton will move as well. In cases where a Rotating Component is used, an alternate Layout may be preferred to prevent other Components from moving as well. This is intentionally left this way to illustrate why this might be the case. A SplitPanel with fixed divider for example would prevent the ToggleButton from moving, while still allowing the Panel to move freely. ******************************************************/ ToggleButtonRecPtr RotateControlButton = ToggleButton::create(); RotateControlButton->setText("Start Rotating"); RotateControlButton->setPreferredSize(Vec2f(100.0f, 29.0f)); RotateControlButton->connectButtonSelected(boost::bind(handleButtonSelected, _1, TutorialWindow.get(), TheRotatedComponent.get())); RotateControlButton->connectButtonDeselected(boost::bind(handleButtonDeselected, _1, TutorialWindow.get(), TheRotatedComponent.get())); // Create The Main InternalWindow // Create Background to be used with the Main InternalWindow ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create(); MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5)); LayoutRecPtr MainInternalWindowLayout = FlowLayout::create(); InternalWindowRecPtr MainInternalWindow = InternalWindow::create(); MainInternalWindow->pushToChildren(TheRotatedComponent); MainInternalWindow->pushToChildren(RotateControlButton); MainInternalWindow->setLayout(MainInternalWindowLayout); MainInternalWindow->setBackgrounds(MainInternalWindowBackground); MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f)); MainInternalWindow->setScalingInDrawingSurface(Vec2f(0.8f,0.8f)); MainInternalWindow->setDrawTitlebar(false); MainInternalWindow->setResizable(false); // Create the Drawing Surface UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create(); TutorialDrawingSurface->setGraphics(TutorialGraphics); TutorialDrawingSurface->setEventProducer(TutorialWindow); TutorialDrawingSurface->openWindow(MainInternalWindow); // Create the UI Foreground Object UIForegroundRecPtr TutorialUIForeground = UIForeground::create(); TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface); // Tell the Manager what to manage sceneManager.setRoot(scene); // Add the UI Foreground Object to the Scene ViewportRecPtr TutorialViewport = sceneManager.getWindow()->getPort(0); TutorialViewport->addForeground(TutorialUIForeground); //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, "30RotatedComponent"); //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)); // Make Torus Node (creates Torus in background of scene) NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16); // Make Main Scene Node and add the Torus NodeRecPtr scene = Node::create(); scene->setCore(Group::create()); scene->addChild(TorusGeometryNode); // Create the Graphics GraphicsRecPtr TutorialGraphics = Graphics2D::create(); // Initialize the LookAndFeelManager to enable default settings LookAndFeelManager::the()->getLookAndFeel()->init(); ColorChooserRecPtr TheColorChooser = ColorChooser::create(); TheColorChooser->setColor(Color4f(1.0f,0.0f,0.0f,1.0f)); // Create Background to be used with the MainInternalWindow ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create(); MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5)); // Create The Internal Window InternalWindowRecPtr MainInternalWindow = InternalWindow::create(); LayoutRecPtr MainInternalWindowLayout = FlowLayout::create(); // Assign the Button to the MainInternalWindow so it will be displayed // when the view is rendered. MainInternalWindow->pushToChildren(TheColorChooser); MainInternalWindow->setLayout(MainInternalWindowLayout); MainInternalWindow->setBackgrounds(MainInternalWindowBackground); MainInternalWindow->setPosition(Pnt2f(50,50)); MainInternalWindow->setPreferredSize(Vec2f(400,400)); MainInternalWindow->setTitle(std::string("Internal Window")); // Create the Drawing Surface UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create(); TutorialDrawingSurface->setGraphics(TutorialGraphics); TutorialDrawingSurface->setEventProducer(TutorialWindow); TutorialDrawingSurface->openWindow(MainInternalWindow); // Create the UI Foreground Object UIForegroundRecPtr TutorialUIForeground = UIForeground::create(); TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface); sceneManager.setRoot(scene); // Add the UI Foreground Object to the Scene ViewportRecPtr TutorialViewport = sceneManager.getWindow()->getPort(0); TutorialViewport->addForeground(TutorialUIForeground); //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, "39ColorChooser"); //Enter main Loop TutorialWindow->mainLoop(); } osgExit(); return 0; }