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);
// 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)
{
osgInit(argc,argv);
// GLUT init
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
int id=glutCreateWindow("OpenSG");
glutReshapeFunc(reshape);
glutDisplayFunc(display);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutKeyboardFunc(keyboard);
GLUTWindowPtr gwin=GLUTWindow::create();
gwin->setId(id);
gwin->init();
// create the scene
NodePtr scene = Node::create();
beginEditCP(scene);
scene->setCore(Group::create());
endEditCP(scene);
// create the SimpleSceneManager helper
_mgr = new SimpleSceneManager;
// tell the manager what to manage
_mgr->setWindow(gwin );
_mgr->setRoot (scene);
// create the geometry.
NodePtr plane = makePlane( 1, 1, 2, 2 );
NodePtr torus = makeTorus( .2, 1, 16, 8 );
GeometryPtr plane_geo, torus_geo;
plane_geo = GeometryPtr::dcast(plane->getCore());
torus_geo = GeometryPtr::dcast(torus->getCore());
PolygonChunkPtr pchunk = PolygonChunk::create();
beginEditCP(pchunk);
pchunk->setFrontMode(GL_LINE);
pchunk->setBackMode(GL_LINE);
pchunk->setOffsetFactor(-1.0);
pchunk->setOffsetLine(true);
endEditCP(pchunk);
// create materials for the plane.
SimpleMaterialPtr pm1 = SimpleMaterial::create();
beginEditCP(pm1);
pm1->setDiffuse( Color3f( 0,1,0 ) );
pm1->setAmbient( Color3f( 0,1,0 ) );
pm1->setSpecular( Color3f( 0,0,0 ) );
endEditCP(pm1);
SimpleMaterialPtr pm2 = SimpleMaterial::create();
beginEditCP(pm2);
pm2->setDiffuse( Color3f( 1,0,0 ) );
pm2->setAmbient( Color3f( 1,0,0 ) );
pm2->setSpecular( Color3f( 0,0,0 ) );
pm2->addChunk(pchunk);
endEditCP(pm2);
MultiPassMaterialPtr mppm = MultiPassMaterial::create();
beginEditCP(mppm);
mppm->addMaterial(pm1);
mppm->addMaterial(pm2);
endEditCP(mppm);
plane_geo->setMaterial(mppm);
// create materials for the torus.
SimpleMaterialPtr tm1 = SimpleMaterial::create();
beginEditCP(tm1);
tm1->setDiffuse( Color3f( 0,0,1 ) );
tm1->setAmbient( Color3f( 0,0,1 ) );
tm1->setTransparency(0.6);
endEditCP(tm1);
SimpleMaterialPtr tm2 = SimpleMaterial::create();
beginEditCP(tm2);
tm2->setDiffuse( Color3f( 1,0,0 ) );
tm2->setAmbient( Color3f( 1,0,0 ) );
tm2->setSpecular( Color3f( 0,0,0 ) );
tm2->addChunk(pchunk);
endEditCP(tm2);
MultiPassMaterialPtr mptm = MultiPassMaterial::create();
beginEditCP(mptm);
mptm->addMaterial(tm1);
mptm->addMaterial(tm2);
endEditCP(mptm);
torus_geo->setMaterial( mptm );
beginEditCP(scene);
scene->addChild(plane);
scene->addChild(torus);
endEditCP(scene);
// show the whole scene
_mgr->showAll();
// GLUT main loop
glutMainLoop();
return 0;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
// Set up Window
TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
TutorialWindow->setDisplayCallback(display);
TutorialWindow->setReshapeCallback(reshape);
TutorialKeyListener TheKeyListener;
TutorialWindow->addKeyListener(&TheKeyListener);
// 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
TutorialBackground = GradientBackground::create();
TutorialBackground->addLine(Color3f(1.0,0.0,0.0), 0.0);
TutorialBackground->addLine(Color3f(0.0,1.0,0.0), 0.2);
TutorialBackground->addLine(Color3f(0.0,0.0,1.0), 0.4);
TutorialBackground->addLine(Color3f(0.0,1.0,1.0), 0.6);
TutorialBackground->addLine(Color3f(1.0,1.0,0.0), 0.8);
TutorialBackground->addLine(Color3f(1.0,1.0,1.0), 1.0);
TheUndoManager = UndoManager::create();
UndoManagerChangeListener TheUndoManagerChangeListener;
TheUndoManager->addChangeListener(&TheUndoManagerChangeListener);
LabelRefPtr SingleFieldLabel = OSG::Label::create();
SingleFieldLabel->setText("Single Field");
SingleFieldLabel->setBorders(NULL);
SingleFieldLabel->setBackgrounds(NULL);
LabelRefPtr MultiFieldLabel = OSG::Label::create();
MultiFieldLabel->setText("Multi Field");
MultiFieldLabel->setBorders(NULL);
MultiFieldLabel->setBackgrounds(NULL);
LabelRefPtr SinglePtrFieldLabel = OSG::Label::create();
SinglePtrFieldLabel->setText("Single Ptr Field");
SinglePtrFieldLabel->setBorders(NULL);
SinglePtrFieldLabel->setBackgrounds(NULL);
LabelRefPtr MultiPtrFieldLabel = OSG::Label::create();
MultiPtrFieldLabel->setText("Multi Ptr Field");
MultiPtrFieldLabel->setBorders(NULL);
MultiPtrFieldLabel->setBackgrounds(NULL);
TabPanelRefPtr ExampleTabPanel = OSG::TabPanel::create();
ExampleTabPanel->setPreferredSize(Vec2f(600,600));
ExampleTabPanel->addTab(SingleFieldLabel, createSingleFieldPanel());
ExampleTabPanel->addTab(MultiFieldLabel, createMultiFieldPanel());
ExampleTabPanel->addTab(SinglePtrFieldLabel, createSinglePtrFieldPanel());
ExampleTabPanel->addTab(MultiPtrFieldLabel, createMultiPtrFieldPanel());
ExampleTabPanel->setTabAlignment(0.5f);
ExampleTabPanel->setTabPlacement(TabPanel::PLACEMENT_NORTH);
ExampleTabPanel->setSelectedIndex(0);
//UndoList
UndoRedoListModel = DefaultListModel::create();
UndoRedoListModel->pushBack(boost::any(std::string("Top")));
ListSelectionModelPtr UndoRedoListSelectionModel(new DefaultListSelectionModel());
UndoRedoList = List::create();
UndoRedoList->setPreferredSize(Vec2f(200, 300));
UndoRedoList->setOrientation(List::VERTICAL_ORIENTATION);
UndoRedoList->setModel(UndoRedoListModel);
UndoRedoList->setSelectionModel(UndoRedoListSelectionModel);
UndoRedoListListener TheUndoRedoListListener;
UndoRedoList->getSelectionModel()->addListSelectionListener(&TheUndoRedoListListener);
UndoButton = OSG::Button::create();
UndoButton->setText("Undo");
UndoButton->setEnabled(TheUndoManager->numberOfUndos() != 0);
UndoButtonActionListener TheUndoButtonActionListener;
UndoButton->addActionListener(&TheUndoButtonActionListener);
RedoButton = OSG::Button::create();
RedoButton->setText("Redo");
RedoButton->setEnabled(TheUndoManager->numberOfRedos() != 0);
RedoButtonActionListener TheRedoButtonActionListener;
RedoButton->addActionListener(&TheRedoButtonActionListener);
// 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);
// 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(ExampleTabPanel);
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);
// 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);
// Create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// Tell the Manager what to manage
mgr->setWindow(TutorialWindow);
mgr->setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRefPtr TutorialViewport = mgr->getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
TutorialViewport->setBackground(TutorialBackground);
// Show the whole Scene
mgr->showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"01ChangeFieldCommands");
//Enter main Loop
TutorialWindow->mainLoop();
osgExit();
return 0;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
// Set up Window
TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
TutorialWindow->setDisplayCallback(display);
TutorialWindow->setReshapeCallback(reshape);
TutorialKeyListener TheKeyListener;
TutorialWindow->addKeyListener(&TheKeyListener);
// 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);
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).
******************************************************/
ToggleButtonRefPtr ExampleToggleButton = OSG::ToggleButton::create();
ExampleToggleButton->setSelected(false);
ExampleToggleButton->setText("ToggleMe");
ExampleToggleButton->setToolTipText("Toggle Button ToolTip");
// Create Background to be used with the MainInternalWindow
ColorLayerRefPtr MainInternalWindowBackground = OSG::ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
// Create The Internal Window
InternalWindowRefPtr MainInternalWindow = OSG::InternalWindow::create();
LayoutRefPtr MainInternalWindowLayout = OSG::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
InternalWindowRefPtr MainInternalWindow2 = OSG::InternalWindow::create();
LayoutRefPtr MainInternalWindowLayout2 = OSG::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("Internal Window 2"));
MainInternalWindow2->setIconable(false);
MainInternalWindow2->setAllwaysOnTop(true);
// Create the Drawing Surface
UIDrawingSurfaceRefPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow2);
// Create the UI Foreground Object
UIForegroundRefPtr TutorialUIForeground = OSG::UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
// Create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// Tell the Manager what to manage
mgr->setWindow(TutorialWindow);
mgr->setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRefPtr TutorialViewport = mgr->getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
// Show the whole Scene
mgr->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;
}
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);
//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));
// Material blend chunk
BlendChunkRefPtr PSBlendChunk = BlendChunk::create();
PSBlendChunk->setSrcFactor(GL_SRC_ALPHA);
PSBlendChunk->setDestFactor(GL_ONE_MINUS_SRC_ALPHA);
//load up images for PS drawer
ImageRefPtr rocket = ImageFileHandler::the()->read("Data/rocket.png");
ImageRefPtr smoke = ImageFileHandler::the()->read("Data/Smokey.png");
//Texture Chunk
TextureObjChunkRefPtr PSRocketTexChunk = TextureObjChunk::create();
PSRocketTexChunk->setImage(rocket);
TextureEnvChunkRefPtr PSRocketTexEnvChunk = TextureEnvChunk::create();
PSRocketTexEnvChunk->setEnvMode(GL_MODULATE);
TextureObjChunkRefPtr SmokeTexChunk = TextureObjChunk::create();
SmokeTexChunk->setImage(smoke);
TextureEnvChunkRefPtr SmokeTexEnvChunk = TextureEnvChunk::create();
SmokeTexEnvChunk->setEnvMode(GL_MODULATE);
//Particle System Material
MaterialChunkRefPtr PSMaterialChunkChunk = MaterialChunk::create();
PSMaterialChunkChunk->setAmbient(Color4f(1.0f,0.5f,0.3f,1.0f));
PSMaterialChunkChunk->setDiffuse(Color4f(1.0f,0.5f,0.3f,0.6f));
PSMaterialChunkChunk->setSpecular(Color4f(1.0f,0.5f,0.3f,0.6f));
PSMaterialChunkChunk->setColorMaterial(GL_AMBIENT_AND_DIFFUSE);
// Assembling materials
ChunkMaterialRefPtr PSMaterial = ChunkMaterial::create();
PSMaterial->addChunk(PSMaterialChunkChunk);
PSMaterial->addChunk(PSBlendChunk);
PSMaterial->addChunk(PSRocketTexChunk);
ChunkMaterialRefPtr TrailMaterial = ChunkMaterial::create();
TrailMaterial->addChunk(PSMaterialChunkChunk);
TrailMaterial->addChunk(PSBlendChunk);
TrailMaterial->addChunk(SmokeTexChunk);
AgeFadeParticleAffectorRefPtr AgeFadeAffector = AgeFadeParticleAffector::create();
AgeFadeAffector->setFadeInTime(0.0f);
AgeFadeAffector->setStartAlpha(1.0f);
AgeFadeAffector->setEndAlpha(0.0f);
AgeFadeAffector->setFadeOutTime(0.35f);
AgeFadeAffector->setFadeToAlpha(1.0f);
// Creating a particle generator
RateParticleGeneratorRefPtr ExampleGenerator = RateParticleGenerator::create();
//Attach the function objects to the Generator
ExampleGenerator->setPositionDistribution(createPositionDistribution());
ExampleGenerator->setGenerationRate(3.0);
ExampleGenerator->setVelocityDistribution(createVelocityDistribution());
ExampleGenerator->setNormalDistribution(createNormalDistribution());
ExampleGenerator->setLifespanDistribution(createLifespanDistribution());
ExampleGenerator->setSizeDistribution(createSizeDistribution());
//Creating Particle System
ParticleSystemRecPtr ExampleParticleSystem = ParticleSystem::create();
ExampleParticleSystem->addParticle(Pnt3f(0,0,-100),Vec3f(0,1,0),Color4f(1,1,1,1),Vec3f(1,1,1),0.1,Vec3f(0,0,0),Vec3f(0,0,0));
ExampleParticleSystem->addParticle(Pnt3f(0,0,100),Vec3f(0,1,0),Color4f(1,1,1,1),Vec3f(1,1,1),0.1,Vec3f(0,0,0),Vec3f(0,0,0));
ExampleParticleSystem->setMaxParticles(5); // 5 rockets max to avoid collisions. they are bad.
ExampleParticleSystem->pushToAffectors(AgeFadeAffector);
ExampleParticleSystem->attachUpdateProducer(TutorialWindow);
//Creating Particle System Drawer
QuadParticleSystemDrawerRefPtr ExampleParticleSystemDrawer = QuadParticleSystemDrawer::create();
ExampleParticleSystemDrawer->setNormalAndUpSource(QuadParticleSystemDrawer::NORMAL_VIEW_DIRECTION,
QuadParticleSystemDrawer::UP_VELOCITY);
QuadParticleSystemDrawerRefPtr ExampleTrailDrawer = QuadParticleSystemDrawer::create();
ExampleTrailDrawer->setNormalAndUpSource(QuadParticleSystemDrawer::NORMAL_VIEW_DIRECTION,
QuadParticleSystemDrawer::UP_PARTICLE_NORMAL);
// Attaching affector and generator to the particle system
ExampleParticleSystem->pushToGenerators(ExampleGenerator);
//Particle System Core, setting its system, drawer, and material
ParticleSystemCoreRefPtr ParticleNodeCore = ParticleSystemCore::create();
ParticleNodeCore->setSystem(ExampleParticleSystem);
ParticleNodeCore->setDrawer(ExampleParticleSystemDrawer);
ParticleNodeCore->setMaterial(PSMaterial);
// create Particle System Particle Trail generator
ParticleSystemParticleTrailGeneratorRecPtr ExamplePSTrailGenerator = ParticleSystemParticleTrailGenerator::create();
ExamplePSTrailGenerator->setTrailResolution(0.05f);
ExamplePSTrailGenerator->setTrailLength(1.2);
ExamplePSTrailGenerator->setTrailLengthMethod(ParticleTrailGenerator::TIME);
ExamplePSTrailGenerator->setTrailResolutionMethod(ParticleTrailGenerator::TIME_SPACING);
ExamplePSTrailGenerator->setTrailMaterial(TrailMaterial);
ExamplePSTrailGenerator->setTrailDrawer(ExampleTrailDrawer);
ExamplePSTrailGenerator->setSizeDistribution(createTrailSizeDistribution());
ExamplePSTrailGenerator->setColorDistribution(createColorDistribution());
ExamplePSTrailGenerator->setNormalDistribution(createNormalDistribution());
ExamplePSTrailGenerator->setVelocityDistribution(createNormalDistribution());
// create affectors for particle trails
GravityParticleAffectorRefPtr GravAffector = GravityParticleAffector::create();
GravAffector->setBeacon(ExamplePSTrailGenerator);
AgeFadeParticleAffectorRefPtr TrailAgeFadeAffector = AgeFadeParticleAffector::create();
TrailAgeFadeAffector->setFadeInTime(0.2f);
TrailAgeFadeAffector->setStartAlpha(0.0f);
TrailAgeFadeAffector->setEndAlpha(0.0f);
TrailAgeFadeAffector->setFadeOutTime(1.0f);
TrailAgeFadeAffector->setFadeToAlpha(0.6f);
// now we attach the affector to the particle trail generator's particle system
ExamplePSTrailGenerator->getParticleSystem()->pushToAffectors(TrailAgeFadeAffector);
// attach listener for trail generator to the particle system
ExamplePSTrailGenerator->setSystemToTrail(ExampleParticleSystem);
//Attach the the update producer to the particle system particle trail generator.
ExamplePSTrailGenerator->attachUpdateProducer(TutorialWindow);
// Set up node with the particle system at its core
NodeRefPtr ParticleNode = Node::create();
ParticleNode->setCore(ParticleNodeCore);
ParticleNode->addChild(ExamplePSTrailGenerator);
// Make Main Scene Node
NodeRefPtr scene = Node::create();
scene->setCore(Group::create());
scene->addChild(ParticleNode);
sceneManager.setRoot(scene);
// Show the whole Scene
sceneManager.showAll();
sceneManager.getCamera()->setFar(10000.0f);
sceneManager.getCamera()->setNear(0.1f);
sceneManager.setStatistics(false);
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"02ParticleSystemParticleTrail");
std::cout << "Controls: " << std::endl
<< "P: Increase Trail Resolution" << std::endl
<< "L: Decrease Trail Resolution" << std::endl
<< "O: Increase Trail Length" << std::endl
<< "K: Decrease Trail Length" << std::endl
<< "J: Toggle calculating trail length by num points/time" << std::endl
<< "Y: Toggle calculating trail point spacing by time/distance" << std::endl
<< "B: Particle burst" << std::endl;
//Enter main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
// Initialize OpenSG and set up the scene
int main(int argc, char **argv)
{
//Set the number of aspects
ThreadManager::setNumAspects(2);
ChangeList::setReadWriteDefault(true);
// OSG init
osgInit(argc,argv);
{
// Set up Window
TutorialWindow = createNativeWindow();
TutorialWindow->setUseCallbackForDraw(true);
TutorialWindow->setUseCallbackForReshape(true);
//Initialize Window
TutorialWindow->initWindow();
// Create the SimpleSceneManager helper
SimpleSceneManager sceneManager;
TutorialWindow->setDisplayCallback(boost::bind(display, &sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, &sceneManager));
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
//Attach to events
TutorialWindow->connectMousePressed(boost::bind(mousePressed, _1, &sceneManager));
TutorialWindow->connectMouseReleased(boost::bind(mouseReleased, _1, &sceneManager));
TutorialWindow->connectMouseMoved(boost::bind(mouseMoved, _1, &sceneManager));
TutorialWindow->connectMouseDragged(boost::bind(mouseDragged, _1, &sceneManager));
//Torus Material
MaterialRecPtr TheTorusMaterial = SimpleMaterial::create();
dynamic_pointer_cast<SimpleMaterial>(TheTorusMaterial)->setAmbient(Color3f(0.2,0.2,0.2));
dynamic_pointer_cast<SimpleMaterial>(TheTorusMaterial)->setDiffuse(Color3f(0.7,0.7,0.7));
dynamic_pointer_cast<SimpleMaterial>(TheTorusMaterial)->setSpecular(Color3f(0.7,0.7,0.7));
dynamic_pointer_cast<SimpleMaterial>(TheTorusMaterial)->setShininess(100.0f);
//Torus Geometry
GeometryRecPtr TorusGeometry = makeTorusGeo(.5, 2, 32, 32);
TorusGeometry->setMaterial(TheTorusMaterial);
NodeRecPtr TorusGeometryNode = Node::create();
TorusGeometryNode->setCore(TorusGeometry);
//Make Torus Node
NodeRecPtr TorusNode = Node::create();
TransformRecPtr TorusNodeTrans = Transform::create();
setName(TorusNodeTrans, std::string("TorusNodeTransformationCore"));
TorusNode->setCore(TorusNodeTrans);
TorusNode->addChild(TorusGeometryNode);
//Make Main Scene Node
NodeRecPtr scene = Node::create();
ComponentTransformRecPtr Trans = ComponentTransform::create();
setName(Trans, std::string("MainTransformationCore"));
scene->setCore(Trans);
scene->addChild(TorusNode);
AnimationRecPtr TheAnimation = setupAnimation(TorusNodeTrans, TutorialWindow);
TutorialWindow->connectKeyPressed(boost::bind(keyPressed, _1, TheAnimation.get(), TutorialWindow.get()));
TheAnimation->connectAnimationStarted(boost::bind(animationStarted, _1));
TheAnimation->connectAnimationStopped(boost::bind(animationStopped, _1));
TheAnimation->connectAnimationPaused(boost::bind(animationPaused, _1));
TheAnimation->connectAnimationUnpaused(boost::bind(animationUnpaused, _1));
TheAnimation->connectAnimationEnded(boost::bind(animationEnded, _1));
TheAnimation->connectAnimationCycled(boost::bind(animationCycled, _1));
commitChanges();
// tell the manager what to manage
sceneManager.setRoot (scene);
// show the whole scene
sceneManager.showAll();
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"OpenSG 01Animation Window");
// store a pointer to the application thread
ApplicationThread = dynamic_cast<OSG::Thread *>(OSG::ThreadManager::getAppThread());
//create the thread that will run generation of new matrices
RenderThread =
OSG::dynamic_pointer_cast<OSG::Thread>(
OSG::ThreadManager::the()->getThread("render", true));
//Start the render thread on aspect 1
RenderThread->runFunction(draw, 1, static_cast<void *>(&sceneManager));
//Enter main Loop
TutorialWindow->mainLoop();
//Stop the render thread
RenderThread->terminate();
}
osgExit();
return 0;
}
int main(int argc, char **argv)
{
preloadSharedObject("OSGImageFileIO");
// 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);
//Attach to events
TutorialWindow->connectMouseReleased(boost::bind(mouseReleased, _1, &sceneManager));
TutorialWindow->connectMouseDragged(boost::bind(mouseDragged, _1, &sceneManager));
TutorialWindow->connectMouseWheelMoved(boost::bind(mouseWheelMoved, _1, &sceneManager));
TutorialWindow->connectKeyTyped(boost::bind(keyTyped, _1, &sceneManager));
//Particle System Material
//point material
PointChunkRefPtr PSPointChunk = PointChunk::create();
PSPointChunk->setSize(5.0f);
PSPointChunk->setSmooth(true);
BlendChunkRefPtr PSBlendChunk = BlendChunk::create();
PSBlendChunk->setSrcFactor(GL_SRC_ALPHA);
PSBlendChunk->setDestFactor(GL_ONE_MINUS_SRC_ALPHA);
MaterialChunkRefPtr PSMaterialChunkChunk = MaterialChunk::create();
PSMaterialChunkChunk->setAmbient(Color4f(0.3f,0.3f,0.3f,1.0f));
PSMaterialChunkChunk->setDiffuse(Color4f(0.7f,0.7f,0.7f,1.0f));
PSMaterialChunkChunk->setSpecular(Color4f(0.9f,0.9f,0.9f,1.0f));
PSMaterialChunkChunk->setColorMaterial(GL_AMBIENT_AND_DIFFUSE);
ChunkMaterialRefPtr PSPointMaterial = ChunkMaterial::create();
PSPointMaterial->addChunk(PSPointChunk);
PSPointMaterial->addChunk(PSMaterialChunkChunk);
PSPointMaterial->addChunk(PSBlendChunk);
//smoke material
TextureObjChunkRefPtr QuadTextureObjChunk = TextureObjChunk::create();
ImageRefPtr LoadedImage = ImageFileHandler::the()->read("Data/Smoke.png");
QuadTextureObjChunk->setImage(LoadedImage);
TextureEnvChunkRefPtr QuadTextureEnvChunk = TextureEnvChunk::create();
QuadTextureEnvChunk->setEnvMode(GL_MODULATE);
MaterialChunkRefPtr PSMaterialChunk = MaterialChunk::create();
PSMaterialChunk->setAmbient(Color4f(0.3f,0.3f,0.3f,1.0f));
PSMaterialChunk->setDiffuse(Color4f(0.7f,0.7f,0.7f,1.0f));
PSMaterialChunk->setSpecular(Color4f(0.9f,0.9f,0.9f,1.0f));
PSMaterialChunk->setColorMaterial(GL_AMBIENT_AND_DIFFUSE);
ChunkMaterialRefPtr PSSmokeMaterial = ChunkMaterial::create();
PSSmokeMaterial->addChunk(QuadTextureObjChunk);
PSSmokeMaterial->addChunk(PSMaterialChunk);
PSSmokeMaterial->addChunk(PSBlendChunk);
PSSmokeMaterial->addChunk(QuadTextureEnvChunk);
//Particle System
//Rocket
ParticleSystemRecPtr RocketParticleSystem = ParticleSystem::create();
RocketParticleSystem->attachUpdateProducer(TutorialWindow);
//smoke
ParticleSystemRecPtr SmokeParticleSystem = ParticleSystem::create();
SmokeParticleSystem->attachUpdateProducer(TutorialWindow);
//Shrapnel
ParticleSystemRecPtr ShrapnelParticleSystem = ParticleSystem::create();
ShrapnelParticleSystem->attachUpdateProducer(TutorialWindow);
//Fireball
ParticleSystemRecPtr FireballParticleSystem = ParticleSystem::create();
FireballParticleSystem->attachUpdateProducer(TutorialWindow);
//Particle System Drawer
//Rocket does not have a drawer because it is being attached to a special node core
//Smoke
QuadParticleSystemDrawerRecPtr SmokeParticleSystemDrawer = QuadParticleSystemDrawer::create();
//SmokeParticleSystemDrawer->setQuadSizeScaling(Vec2f(0.5f,0.5f));
//Shrapnel
PointParticleSystemDrawerRecPtr ExampleShrapnelParticleSystemDrawer = PointParticleSystemDrawer::create();
ExampleShrapnelParticleSystemDrawer->setForcePerParticleSizing(true);
//Fireball
PointParticleSystemDrawerRecPtr ExampleFireballParticleSystemDrawer = PointParticleSystemDrawer::create();
ExampleFireballParticleSystemDrawer->setForcePerParticleSizing(true);
//Particle System Node
//collision node
//NodeRefPtr EnvironmentNode = makeSphere(2,4.0f);
Matrix EnvironmentTransformation;
EnvironmentTransformation.setTranslate(0.0f,0.0f,10.0f);
TransformRefPtr EnvironmentTransformCore = Transform::create();
EnvironmentTransformCore->setMatrix(EnvironmentTransformation);
NodeRefPtr EnvironmentNode = Node::create();
EnvironmentNode->setCore(EnvironmentTransformCore);
NodeRefPtr EnvironmentGeoNode = SceneFileHandler::the()->read("Data/house.obj");
if(EnvironmentGeoNode == NULL)
{
EnvironmentGeoNode = makeTorus(.5, 2, 16, 16);
}
EnvironmentNode->addChild(EnvironmentGeoNode);
NodeRefPtr RocketParticlePrototypeNode = SceneFileHandler::the()->read("Data/rocket.obj");
if(RocketParticlePrototypeNode == NULL)
{
RocketParticlePrototypeNode = makeTorus(.2, 0.8, 16, 16);
}
NodeParticleSystemCoreRefPtr RocketParticleNodeCore = NodeParticleSystemCore::create();
RocketParticleNodeCore->setSystem(RocketParticleSystem);
RocketParticleNodeCore->setPrototypeNode(RocketParticlePrototypeNode);
RocketParticleNodeCore->setNormalSource(NodeParticleSystemCore::NORMAL_VELOCITY);
RocketParticleNodeCore->setUpSource(NodeParticleSystemCore::UP_PARTICLE_NORMAL);
RocketParticleNodeCore->setUp(Vec3f(0.0f,1.0f,0.0f));
//Geometry Collision Affector
GeometryCollisionParticleSystemAffectorRefPtr ExampleGeometryCollisionParticleSystemAffector = GeometryCollisionParticleSystemAffector::create();
ExampleGeometryCollisionParticleSystemAffector->setCollisionNode(EnvironmentNode);
ExampleGeometryCollisionParticleSystemAffector->connectParticleCollision(boost::bind(particleCollision, _1));
NodeRefPtr RocketParticleNode = Node::create();
RocketParticleNode->setCore(RocketParticleNodeCore);
//Attach the Affector to the Rocket Particle System
//RocketParticleSystem->pushToAffectors();
RocketParticleSystem->pushToSystemAffectors(ExampleGeometryCollisionParticleSystemAffector);
//Smoke
RateParticleGeneratorRecPtr SmokeGenerator = RateParticleGenerator::create();
//Attach the function objects to the Generator
Distribution3DRefPtr SmokePositionDistribution = createSmokePositionDistribution();
SmokeGenerator->setPositionDistribution(SmokePositionDistribution);
SmokeGenerator->setLifespanDistribution(createSmokeLifespanDistribution());
SmokeGenerator->setGenerationRate(50.0);
SmokeGenerator->setVelocityDistribution(createSmokeVelocityDistribution());
//Attach the function objects the Affectors
AgeFadeParticleAffectorRecPtr SmokeAgeFadeParticleAffector = AgeFadeParticleAffector::create();
SmokeAgeFadeParticleAffector->setFadeInTime(2.0f);
SmokeAgeFadeParticleAffector->setFadeOutTime(5.0f);
SmokeAgeFadeParticleAffector->setStartAlpha(0.0f);
SmokeAgeFadeParticleAffector->setFadeToAlpha(0.2f);
SmokeAgeFadeParticleAffector->setEndAlpha(0.0f);
AgeSizeParticleAffectorRecPtr SmokeAgeSizeParticleAffector = AgeSizeParticleAffector::create();
//ages
SmokeAgeSizeParticleAffector->editMFAges()->push_back(0.1);
SmokeAgeSizeParticleAffector->editMFAges()->push_back(0.2);
SmokeAgeSizeParticleAffector->editMFAges()->push_back(0.3);
SmokeAgeSizeParticleAffector->editMFAges()->push_back(0.5);
SmokeAgeSizeParticleAffector->editMFAges()->push_back(0.7);
SmokeAgeSizeParticleAffector->editMFAges()->push_back(0.8);
SmokeAgeSizeParticleAffector->editMFAges()->push_back(1.0);
//sizes
SmokeAgeSizeParticleAffector->editMFSizes()->push_back(Vec3f(0.5,0.5,0.5));
SmokeAgeSizeParticleAffector->editMFSizes()->push_back(Vec3f(1.0,1.0,1.0));
SmokeAgeSizeParticleAffector->editMFSizes()->push_back(Vec3f(2.0,2.0,2.0));
SmokeAgeSizeParticleAffector->editMFSizes()->push_back(Vec3f(3.0,3.0,3.0));
SmokeAgeSizeParticleAffector->editMFSizes()->push_back(Vec3f(4.0,4.0,4.0));
SmokeAgeSizeParticleAffector->editMFSizes()->push_back(Vec3f(5.0,5.0,5.0));
SmokeAgeSizeParticleAffector->editMFSizes()->push_back(Vec3f(6.5,6.5,6.5));
ParticleSystemCoreRefPtr SmokeParticleNodeCore = ParticleSystemCore::create();
SmokeParticleNodeCore->setSystem(SmokeParticleSystem);
SmokeParticleNodeCore->setDrawer(SmokeParticleSystemDrawer);
SmokeParticleNodeCore->setMaterial(PSSmokeMaterial);
NodeRefPtr SmokeParticleNode = Node::create();
SmokeParticleNode->setCore(SmokeParticleNodeCore);
//end/////////////////////
//Shrapnel
BurstParticleGeneratorRecPtr ShrapnelBurstGenerator = BurstParticleGenerator::create();
NodeRefPtr ShrapnelParticlePrototypeNode = SceneFileHandler::the()->read("Data/Shrapnel.obj");
NodeParticleSystemCoreRefPtr ShrapnelParticleNodeCore = NodeParticleSystemCore::create();
ShrapnelParticleNodeCore->setSystem(ShrapnelParticleSystem);
ShrapnelParticleNodeCore->setPrototypeNode(ShrapnelParticlePrototypeNode);
//Attach the function objects to the Generator
Distribution3DRefPtr ShrapnelPositionDistribution = createShrapnelPositionDistribution();
ShrapnelBurstGenerator->setPositionDistribution(ShrapnelPositionDistribution);
ShrapnelBurstGenerator->setLifespanDistribution(createLifespanDistribution());
ShrapnelBurstGenerator->setBurstAmount(50.0);
ShrapnelBurstGenerator->setVelocityDistribution(createShrapnelVelocityDistribution());
ShrapnelBurstGenerator->setAccelerationDistribution(createShrapnelAccelerationDistribution());
NodeRefPtr ShrapnelParticleNode = Node::create();
ShrapnelParticleNode->setCore(ShrapnelParticleNodeCore);
//end/////////////////////
//fireball
BurstParticleGeneratorRecPtr FireballGenerator = BurstParticleGenerator::create();
NodeRefPtr FireballParticlePrototypeNode = SceneFileHandler::the()->read("Data/bubble.obj");
NodeParticleSystemCoreRefPtr FireballParticleNodeCore = NodeParticleSystemCore::create();
FireballParticleNodeCore->setSystem(FireballParticleSystem);
FireballParticleNodeCore->setPrototypeNode(FireballParticlePrototypeNode);
//Attach the function objects to the Generator
Distribution3DRefPtr FireballPositionDistribution = createFireballPositionDistribution();
FireballGenerator->setPositionDistribution(FireballPositionDistribution);
FireballGenerator->setLifespanDistribution(createFireballLifespanDistribution());
FireballGenerator->setBurstAmount(100.0);
FireballGenerator->setVelocityDistribution(createFireballVelocityDistribution());
FireballGenerator->setAccelerationDistribution(createFireballAccelerationDistribution());
//Attach the function objects the Affectors
AgeSizeParticleAffectorRecPtr FireballAgeSizeParticleAffector = AgeSizeParticleAffector::create();
//ages
FireballAgeSizeParticleAffector->editMFAges()->push_back(0.1);
FireballAgeSizeParticleAffector->editMFAges()->push_back(0.2);
FireballAgeSizeParticleAffector->editMFAges()->push_back(0.3);
FireballAgeSizeParticleAffector->editMFAges()->push_back(0.5);
FireballAgeSizeParticleAffector->editMFAges()->push_back(0.7);
FireballAgeSizeParticleAffector->editMFAges()->push_back(0.8);
FireballAgeSizeParticleAffector->editMFAges()->push_back(1.0);
//sizes
FireballAgeSizeParticleAffector->editMFSizes()->push_back(Vec3f(2.0,2.0,2.0));
FireballAgeSizeParticleAffector->editMFSizes()->push_back(Vec3f(2.3,2.3,2.3));
FireballAgeSizeParticleAffector->editMFSizes()->push_back(Vec3f(2.5,2.5,2.5));
FireballAgeSizeParticleAffector->editMFSizes()->push_back(Vec3f(3.0,3.0,3.0));
FireballAgeSizeParticleAffector->editMFSizes()->push_back(Vec3f(4.0,4.0,4.0));
FireballAgeSizeParticleAffector->editMFSizes()->push_back(Vec3f(5.0,5.0,5.0));
FireballAgeSizeParticleAffector->editMFSizes()->push_back(Vec3f(6.5,6.5,6.5));
NodeRefPtr FireballParticleNode = Node::create();
FireballParticleNode->setCore(FireballParticleNodeCore);
//end/////////////////////
//Attach the Affector to the Smoke Particle System
SmokeParticleSystem->pushToAffectors(SmokeAgeFadeParticleAffector);
SmokeParticleSystem->pushToAffectors(SmokeAgeSizeParticleAffector);
//Attach the Affector to the fireball Particle System
FireballParticleSystem->pushToAffectors(FireballAgeSizeParticleAffector);
// Make Main Scene Node
NodeRefPtr scene = Node::create();
scene->setCore(Group::create());
scene->addChild(RocketParticleNode);
scene->addChild(SmokeParticleNode);
scene->addChild(ShrapnelParticleNode);
scene->addChild(FireballParticleNode);
scene->addChild(EnvironmentNode);
RocketParticleSystem->connectParticleKilled(boost::bind(particleKilled, _1,
ShrapnelParticleSystem.get(),
ShrapnelBurstGenerator.get(),
SmokeParticleSystem.get(),
SmokeGenerator.get(),
FireballParticleSystem.get(),
FireballGenerator.get()));
TutorialWindow->connectMousePressed(boost::bind(mousePressed, _1,
&sceneManager,
RocketParticleSystem.get()));
sceneManager.setRoot(scene);
//Create the Documentation
SimpleScreenDoc TheSimpleScreenDoc(&sceneManager, TutorialWindow);
sceneManager.getNavigator()->set(Pnt3f(0.0,0.0,-10.0), Pnt3f(0.0,0.0,0.0), Vec3f(0.0,1.0,0.0));
sceneManager.getNavigator()->setMotionFactor(1.0f);
sceneManager.getCamera()->setNear(0.1f);
sceneManager.getCamera()->setFar(1000.0f);
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"20RocketLauncher");
//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);
// GLUT init
int winid = setupGLUT(&argc, argv);
// the connection between GLUT and OpenSG
GLUTWindowPtr gwin= GLUTWindow::create();
gwin->setId(winid);
gwin->init();
// create the scene
/*
In the previous example, the colors and positions used the same
indices. That might not always be the preferred way, and it might not
make sense for other properties, e.g. normals.
It is possible to assign a different index for every property. See the
indices section below for details.
*/
/*
The initial setup is the same as in the single indexed geometry...
*/
GeoPTypesPtr type = GeoPTypesUI8::create();
beginEditCP(type, GeoPTypesUI8::GeoPropDataFieldMask);
{
type->push_back(GL_POLYGON );
type->push_back(GL_TRIANGLES);
type->push_back(GL_QUADS );
}
endEditCP (type, GeoPTypesUI8::GeoPropDataFieldMask);
GeoPLengthsPtr lens = GeoPLengthsUI32::create();
beginEditCP(lens, GeoPLengthsUI32::GeoPropDataFieldMask);
{
lens->push_back(4);
lens->push_back(6);
lens->push_back(8);
}
endEditCP (lens, GeoPLengthsUI32::GeoPropDataFieldMask);
GeoPositions3fPtr pnts = GeoPositions3f::create();
beginEditCP(pnts, GeoPositions3f::GeoPropDataFieldMask);
{
// the base
pnts->push_back(Pnt3f(-1, -1, -1));
pnts->push_back(Pnt3f(-1, -1, 1));
pnts->push_back(Pnt3f( 1, -1, 1));
pnts->push_back(Pnt3f( 1, -1, -1));
// the roof base
pnts->push_back(Pnt3f(-1, 0, -1));
pnts->push_back(Pnt3f(-1, 0, 1));
pnts->push_back(Pnt3f( 1, 0, 1));
pnts->push_back(Pnt3f( 1, 0, -1));
// the gable
pnts->push_back(Pnt3f( 0, 1, -1));
pnts->push_back(Pnt3f( 0, 1, 1));
}
endEditCP (pnts, GeoPositions3f::GeoPropDataFieldMask);
GeoColors3fPtr colors = GeoColors3f::create();
beginEditCP(colors, GeoColors3f::GeoPropDataFieldMask);
{
colors->push_back(Color3f(1, 1, 0));
colors->push_back(Color3f(1, 0, 0));
colors->push_back(Color3f(1, 0, 0));
colors->push_back(Color3f(1, 1, 0));
colors->push_back(Color3f(0, 1, 1));
colors->push_back(Color3f(1, 0, 1));
}
endEditCP (colors, GeoPositions3f::GeoPropDataFieldMask);
/*
A new property: normals.
They are used for lighting calculations and have to point away from the
surface. Normals are standard vectors.
*/
GeoNormals3fPtr norms = GeoNormals3f::create();
beginEditCP(norms, GeoNormals3f::GeoPropDataFieldMask);
{
norms->push_back(Vec3f(-1, 0, 0));
norms->push_back(Vec3f( 1, 0, 0));
norms->push_back(Vec3f( 0, -1, 0));
norms->push_back(Vec3f( 0, 1, 0));
norms->push_back(Vec3f( 0, 0, -1));
norms->push_back(Vec3f( 0, 0, 1));
}
endEditCP (norms, GeoNormals3f::GeoPropDataFieldMask);
/*
To use different indices for different attributes they have to be
specified. This is done within the single index property, by using more
than one index per vertex.
In this case every vertex reads multiple indices from the Indices
property. The meaning of every index is defined by the indexMapping
given below.
*/
GeoIndicesUI32Ptr indices = GeoIndicesUI32::create();
beginEditCP(indices, GeoIndicesUI32::GeoPropDataFieldMask);
{
// indices for the polygon
indices->push_back(0); // position index
indices->push_back(3); // color/normal index
indices->push_back(1); // position index
indices->push_back(3); // color/normal index
indices->push_back(2); // position index
indices->push_back(3); // color/normal index
indices->push_back(3); // position index
indices->push_back(3); // color/normal index
// indices for the triangles
indices->push_back(7); // position index
indices->push_back(4); // color/normal index
indices->push_back(4); // position index
indices->push_back(4); // color/normal index
indices->push_back(8); // position index
indices->push_back(4); // color/normal index
indices->push_back(5); // position index
indices->push_back(5); // color/normal index
indices->push_back(6); // position index
indices->push_back(5); // color/normal index
indices->push_back(9); // position index
indices->push_back(5); // color/normal index
// indices for the quads
indices->push_back(1); // position index
indices->push_back(5); // color/normal index
indices->push_back(2); // position index
indices->push_back(5); // color/normal index
indices->push_back(6); // position index
indices->push_back(5); // color/normal index
indices->push_back(5); // position index
indices->push_back(5); // color/normal index
indices->push_back(3); // position index
indices->push_back(4); // color/normal index
indices->push_back(0); // position index
indices->push_back(4); // color/normal index
indices->push_back(4); // position index
indices->push_back(4); // color/normal index
indices->push_back(7); // position index
indices->push_back(4); // color/normal index
}
endEditCP (indices, GeoIndicesUI32::GeoPropDataFieldMask);
/*
Put it all together into a Geometry NodeCore.
*/
GeometryPtr geo=Geometry::create();
beginEditCP(geo, Geometry::TypesFieldMask |
Geometry::LengthsFieldMask |
Geometry::IndicesFieldMask |
Geometry::IndexMappingFieldMask |
Geometry::PositionsFieldMask |
Geometry::NormalsFieldMask |
Geometry::ColorsFieldMask |
Geometry::MaterialFieldMask );
{
geo->setTypes (type);
geo->setLengths (lens);
geo->setIndices (indices);
/*
The meaning of the different indices is given by the indexMapping
field.
If contains an entry that defines which index for a vertex
selects which attribute. In this example the first index selects
the positions, the second is used for colors and normals.
The number of elements in the indexMapping field defines the
number of indices used for every vertex.
*/
geo->editMFIndexMapping()->push_back(Geometry::MapPosition );
geo->editMFIndexMapping()->push_back(Geometry::MapColor |
Geometry::MapNormal );
geo->setPositions(pnts );
geo->setColors (colors);
geo->setNormals (norms );
/*
Use a lit material this time, to show the effect of the normals.
*/
geo->setMaterial (getDefaultMaterial());
}
endEditCP (geo, Geometry::TypesFieldMask |
Geometry::LengthsFieldMask |
Geometry::IndicesFieldMask |
Geometry::IndexMappingFieldMask |
Geometry::PositionsFieldMask |
Geometry::NormalsFieldMask |
Geometry::ColorsFieldMask |
Geometry::MaterialFieldMask );
// put the geometry core into a node
NodePtr n = Node::create();
beginEditCP(n, Node::CoreFieldMask);
{
n->setCore(geo);
}
endEditCP (n, Node::CoreFieldMask);
// add a transformation to make it move
NodePtr scene = Node::create();
trans = Transform::create();
beginEditCP(scene, Node::CoreFieldMask | Node::ChildrenFieldMask );
{
scene->setCore(trans);
scene->addChild(n);
}
endEditCP (scene, Node::CoreFieldMask | Node::ChildrenFieldMask );
// create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// tell the manager what to manage
mgr->setWindow(gwin );
mgr->setRoot (scene);
// show the whole scene
mgr->showAll();
// GLUT main loop
glutMainLoop();
return 0;
}
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
TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
TutorialWindow->setDisplayCallback(display);
TutorialWindow->setReshapeCallback(reshape);
TutorialKeyListener TheKeyListener;
TutorialWindow->addKeyListener(&TheKeyListener);
// 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 a simple Font to be used with the TextField
UIFontRefPtr sampleFont = OSG::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
TextFieldRefPtr ExampleTextField = OSG::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
TextFieldRefPtr ExampleTextField2 = OSG::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
ColorLayerRefPtr MainInternalWindowBackground = OSG::ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
LayoutRefPtr MainInternalWindowLayout = OSG::FlowLayout::create();
InternalWindowRefPtr MainInternalWindow = OSG::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
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);
// Create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// Tell the Manager what to manage
mgr->setWindow(TutorialWindow);
mgr->setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRefPtr TutorialViewport = mgr->getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
// Show the whole Scene
mgr->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;
}
// Initialize GLUT & OpenSG and set up the scene
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
{
// Set up Window
WindowEventProducerRecPtr TutorialWindow = createNativeWindow();
//Initialize Window
TutorialWindow->initWindow();
SimpleSceneManager sceneManager;
TutorialWindow->setDisplayCallback(boost::bind(display, &sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, &sceneManager));
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
//Attach to events
TutorialWindow->connectMousePressed(boost::bind(mousePressed, _1, &sceneManager));
TutorialWindow->connectMouseReleased(boost::bind(mouseReleased, _1, &sceneManager));
TutorialWindow->connectMouseDragged(boost::bind(mouseDragged, _1, &sceneManager));
TutorialWindow->connectMouseWheelMoved(boost::bind(mouseWheelMoved, _1, &sceneManager));
//Torus Material
SimpleMaterialUnrecPtr TheTorusMaterial = SimpleMaterial::create();
TheTorusMaterial->setAmbient(Color3f(0.3,0.3,0.3));
TheTorusMaterial->setDiffuse(Color3f(0.7,0.7,0.7));
TheTorusMaterial->setSpecular(Color3f(1.0,1.0,1.0));
TheTorusMaterial->setShininess(20.0);
//Torus Geometry
GeometryUnrecPtr TorusGeometry = makeTorusGeo(.5, 2, 32, 32);
TorusGeometry->setMaterial(TheTorusMaterial);
NodeUnrecPtr TorusGeometryNode = Node::create();
TorusGeometryNode->setCore(TorusGeometry);
//Make Torus Node
NodeUnrecPtr TorusNode = Node::create();
TransformUnrecPtr TorusNodeTrans = Transform::create();
setName(TorusNodeTrans, std::string("TorusNodeTransformationCore"));
TorusNode->setCore(TorusNodeTrans);
TorusNode->addChild(TorusGeometryNode);
//Make Main Scene Node
NodeUnrecPtr scene = Node::create();
ComponentTransformUnrecPtr Trans = ComponentTransform::create();
setName(Trans, std::string("MainTransformationCore"));
scene->setCore(Trans);
// add the torus as a child
scene->addChild(TorusNode);
AnimationGroupUnrecPtr TheAnimation = setupAnimation(TheTorusMaterial, TorusNodeTrans);
TutorialWindow->connectKeyPressed(boost::bind(keyPressed, _1,
TheAnimation.get(),
TutorialWindow.get()));
TheAnimation->attachUpdateProducer(TutorialWindow);
TheAnimation->start();
// tell the manager what to manage
sceneManager.setRoot (scene);
//Create the Documentation
SimpleScreenDoc TheSimpleScreenDoc(&sceneManager, TutorialWindow);
// show the whole scene
sceneManager.showAll();
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"07AnimationGroup");
//Enter main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
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);
//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));
//Particle System Material
MaterialChunkRefPtr PSMaterialChunkChunk = MaterialChunk::create();
PSMaterialChunkChunk->setAmbient(Color4f(0.3f,0.3f,0.3f,1.0f));
PSMaterialChunkChunk->setDiffuse(Color4f(0.7f,0.7f,0.7f,1.0f));
PSMaterialChunkChunk->setSpecular(Color4f(0.9f,0.9f,0.9f,1.0f));
PSMaterialChunkChunk->setColorMaterial(GL_AMBIENT_AND_DIFFUSE);
ChunkMaterialRefPtr PSMaterial = ChunkMaterial::create();
PSMaterial->addChunk(PSMaterialChunkChunk);
Distribution3DRefPtr PositionDistribution = createPositionDistribution();
Pnt3f PositionReturnValue;
//Particle System
ParticleSystemRecPtr ExampleParticleSystem = ParticleSystem::create();
for(UInt32 i(0) ; i<500 ; ++i)//controls how many particles are created
{
if(PositionDistribution != NULL)
{
PositionReturnValue = Pnt3f(PositionDistribution->generate());
}
ExampleParticleSystem->addParticle(
PositionReturnValue,
PositionReturnValue,
Vec3f(0.0f,0.0f,1.0f),
Color4f(1.0,0.0,0.0,1.0),
Vec3f(1.0,1.0,1.0),
-1, 0,
Vec3f(0.0,0.0,0.0), Vec3f(0.0f,0.0f,0.0f), //Velocity
Vec3f(0.0f,0.0f,0.0f), //acceleration
StringToUInt32Map() );
}
ExampleParticleSystem->attachUpdateProducer(TutorialWindow);
RandomMovementParticleAffectorRecPtr ExampleRMA = RandomMovementParticleAffector::create();
ExampleRMA->setAmplitude(100.0f);
AttributeAttractRepelParticleAffectorRecPtr ExampleAttributeAttractRepelParticleAffector = AttributeAttractRepelParticleAffector::create();
ExampleAttributeAttractRepelParticleAffector->setAttributeAffected(RandomMovementParticleAffector::POSITION_ATTRIBUTE);
ExampleAttributeAttractRepelParticleAffector->setMinDistance(0.0);
ExampleAttributeAttractRepelParticleAffector->setMaxDistance(10000000000000.0);
ExampleAttributeAttractRepelParticleAffector->setQuadratic(0.01);
ExampleAttributeAttractRepelParticleAffector->setLinear(0.01);
ExampleAttributeAttractRepelParticleAffector->setConstant(0.0);
ExampleParticleSystem->pushToAffectors(ExampleRMA);
ExampleParticleSystem->pushToAffectors(ExampleAttributeAttractRepelParticleAffector);
ExampleParticleSystem->setUpdateSecAttribs(false);
//Particle System Drawer
QuadParticleSystemDrawerRefPtr ExampleParticleSystemDrawer = QuadParticleSystemDrawer::create();
//Particle System Node
ParticleSystemCoreRefPtr ParticleNodeCore = ParticleSystemCore::create();
ParticleNodeCore->setSystem(ExampleParticleSystem);
ParticleNodeCore->setDrawer(ExampleParticleSystemDrawer);
ParticleNodeCore->setMaterial(PSMaterial);
NodeRefPtr ParticleNode = Node::create();
ParticleNode->setCore(ParticleNodeCore);
// Make Main Scene Node
NodeRefPtr scene = Node::create();
scene->setCore(Group::create());
scene->addChild(ParticleNode);
TutorialWindow->connectKeyTyped(boost::bind(keyTyped, _1,
&sceneManager,
ExampleParticleSystem.get(),
ExampleRMA.get(),
ExampleAttributeAttractRepelParticleAffector.get()));
sceneManager.setRoot(scene);
// Show the whole Scene
sceneManager.showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"17RandomMovement");
//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
TutorialWindowEventProducer = createDefaultWindowEventProducer();
WindowPtr MainWindow = TutorialWindowEventProducer->initWindow();
TutorialWindowEventProducer->setDisplayCallback(display);
TutorialWindowEventProducer->setReshapeCallback(reshape);
//Add Window Listener
TutorialKeyListener TheKeyListener;
TutorialWindowEventProducer->addKeyListener(&TheKeyListener);
TutorialMouseListener TheTutorialMouseListener;
TutorialMouseMotionListener TheTutorialMouseMotionListener;
TutorialWindowEventProducer->addMouseListener(&TheTutorialMouseListener);
TutorialWindowEventProducer->addMouseMotionListener(&TheTutorialMouseMotionListener);
// Create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// Tell the Manager what to manage
mgr->setWindow(TutorialWindowEventProducer->getWindow());
Path FBOFilePath;
if(argc < 2)
{
FWARNING(("No FBO file given!\n"));
FBOFilePath = Path("./Data/01LoadFBO.xml");
}
else
{
FBOFilePath = Path(std::string(argv[1]));
}
std::cout << "Loading xml File: " << FBOFilePath << std::endl;
FCFileType::FCPtrStore NewContainers;
NewContainers = FCFileHandler::the()->read(FBOFilePath);
FCFileType::FCPtrStore::iterator Itor;
for(Itor = NewContainers.begin() ; Itor != NewContainers.end() ; ++Itor)
{
if( (*Itor)->getType() == FBOViewport::getClassType())
{
TheFBOViewport = FBOViewport::Ptr::dcast(*Itor);
}
}
ChunkMaterialPtr BoxMaterial = ChunkMaterial::create();
GeometryPtr BoxGeoCore = makeBoxGeo(1.0,1.0,1.0,2,2,2);
beginEditCP(BoxGeoCore, Geometry::MaterialFieldMask);
BoxGeoCore->setMaterial(BoxMaterial);
endEditCP(BoxGeoCore, Geometry::MaterialFieldMask);
NodePtr BoxGeoNode = Node::create();
beginEditCP(BoxGeoNode, Node::CoreFieldMask);
BoxGeoNode->setCore(BoxGeoCore);
endEditCP(BoxGeoNode, Node::CoreFieldMask);
NodePtr SceneNode = Node::create();
beginEditCP(SceneNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
SceneNode->setCore(Group::create());
SceneNode->addChild(BoxGeoNode);
endEditCP(SceneNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
// tell the manager what to manage
mgr->setRoot (SceneNode);
// show the whole scene
mgr->showAll();
if(TheFBOViewport != NullFC)
{
//Add the texture chunk of the FBO to the Material for the box
beginEditCP(BoxMaterial, ChunkMaterial::ChunksFieldMask);
BoxMaterial->addChunk(TheFBOViewport->editTextures(0));
endEditCP(BoxMaterial, ChunkMaterial::ChunksFieldMask);
//Add The FBO Viewport the the Window
beginEditCP(TheFBOViewport, FBOViewport::ParentFieldMask);
TheFBOViewport->setParent(TutorialWindowEventProducer->getWindow());
endEditCP(TheFBOViewport, FBOViewport::ParentFieldMask);
beginEditCP(TutorialWindowEventProducer->getWindow());
ViewportPtr vp = TutorialWindowEventProducer->getWindow()->getPort(0);
addRefCP(vp);
TutorialWindowEventProducer->getWindow()->subPort(0);
//Put the FBO Vieport in front, so it is rendered first
TutorialWindowEventProducer->getWindow()->addPort(TheFBOViewport);
TutorialWindowEventProducer->getWindow()->addPort(vp );
endEditCP (TutorialWindowEventProducer->getWindow());
}
Vec2f WinSize(TutorialWindowEventProducer->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindowEventProducer->getDesktopSize() - WinSize) *0.5);
TutorialWindowEventProducer->openWindow(WinPos,
WinSize,
"07LoadFBO");
//Main Loop
TutorialWindowEventProducer->mainLoop();
osgExit();
return 0;
}
// Initialize GLUT & OpenSG and set up the scene
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
// GLUT init
int winid = setupGLUT(&argc, argv);
// the connection between GLUT and OpenSG
GLUTWindowPtr gwin= GLUTWindow::create();
gwin->setId(winid);
gwin->init();
// create the scene
/*
Geometry data in OpenSG is stored in several separate vectors.
These vectors are not a direct part of the Geometry Core but
rather split up into multiple separate classes.
These classes, the GeoProperties, contain a single field containg
their values, which can be accessed directly, see the docs for
GeoProperty for the whole interface.
*/
/*
The first part: the primtive types.
These are taken from OpenGL, any values that can be passed to
glBegin(); are legal. Different types can be freely mixed.
All properties have only one field, which has the same name for every
property, thus the mask is also called the same for each property.
*/
GeoPTypesPtr type = GeoPTypesUI8::create();
beginEditCP(type, GeoPTypesUI8::GeoPropDataFieldMask);
{
type->addValue(GL_POLYGON );
type->addValue(GL_TRIANGLES);
type->addValue(GL_QUADS );
}
endEditCP (type, GeoPTypesUI8::GeoPropDataFieldMask);
/*
The second part: the primtive lengths.
These define the number of vertices to be passed to OpenGL for each
primitive. Thus there have to be at least as many entries as in the
types property.
*/
GeoPLengthsPtr lens = GeoPLengthsUI32::create();
beginEditCP(lens, GeoPLengthsUI32::GeoPropDataFieldMask);
{
lens->addValue(4);
lens->addValue(6);
lens->addValue(8);
}
endEditCP (lens, GeoPLengthsUI32::GeoPropDataFieldMask);
/*
The third part: the vertex positions.
OpenSG uses different types for vectors and points.
Points (e.g. Pnt3f) are just positions in space, they have a limited
set of operations they can handle. Vectors (e.g. Vec3f) are the more
general kind.
*/
GeoPositions3fPtr pnts = GeoPositions3f::create();
beginEditCP(pnts, GeoPositions3f::GeoPropDataFieldMask);
{
// the 4 points of the polygon
pnts->addValue(Pnt3f(-1, -1, -1));
pnts->addValue(Pnt3f(-1, -1, 1));
pnts->addValue(Pnt3f( 1, -1, 1));
pnts->addValue(Pnt3f( 1, -1, -1));
// the 6 points of the two triangles
pnts->addValue(Pnt3f( 1, 0, -1));
pnts->addValue(Pnt3f(-1, 0, -1));
pnts->addValue(Pnt3f( 0, 1, -1));
pnts->addValue(Pnt3f(-1, 0, 1));
pnts->addValue(Pnt3f( 1, 0, 1));
pnts->addValue(Pnt3f( 0, 1, 1));
// the 8 points of the two quads
pnts->addValue(Pnt3f(-1, -1, 1));
pnts->addValue(Pnt3f( 1, -1, 1));
pnts->addValue(Pnt3f( 1, 0, 1));
pnts->addValue(Pnt3f(-1, 0, 1));
pnts->addValue(Pnt3f( 1, -1, -1));
pnts->addValue(Pnt3f(-1, -1, -1));
pnts->addValue(Pnt3f(-1, 0, -1));
pnts->addValue(Pnt3f( 1, 0, -1));
}
endEditCP (pnts, GeoPositions3f::GeoPropDataFieldMask);
/*
Put it all together into a Geometry NodeCore.
*/
geo=Geometry::create();
beginEditCP(geo, Geometry::TypesFieldMask |
Geometry::LengthsFieldMask |
Geometry::PositionsFieldMask |
Geometry::MaterialFieldMask );
{
geo->setTypes (type);
geo->setLengths (lens);
geo->setPositions(pnts);
// assign a material to the geometry to make it visible. The details
// of materials are defined later.
geo->setMaterial(getDefaultUnlitMaterial());
}
endEditCP (geo, Geometry::TypesFieldMask |
Geometry::LengthsFieldMask |
Geometry::PositionsFieldMask |
Geometry::MaterialFieldMask );
// put the geometry core into a node
NodePtr n = Node::create();
beginEditCP(n, Node::CoreFieldMask);
{
n->setCore(geo);
}
endEditCP (n, Node::CoreFieldMask);
// add a transformation to make it move
NodePtr scene = Node::create();
trans = Transform::create();
beginEditCP(scene, Node::CoreFieldMask | Node::ChildrenFieldMask );
{
scene->setCore(trans);
scene->addChild(n);
}
endEditCP (scene, Node::CoreFieldMask | Node::ChildrenFieldMask );
// create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// tell the manager what to manage
mgr->setWindow(gwin );
mgr->setRoot (scene);
// show the whole scene
mgr->showAll();
// GLUT main loop
glutMainLoop();
return 0;
}
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));
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;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
// Set up Window
TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
TutorialWindow->setDisplayCallback(display);
TutorialWindow->setReshapeCallback(reshape);
TutorialKeyListener TheKeyListener;
TutorialWindow->addKeyListener(&TheKeyListener);
TutorialMouseListener TheTutorialMouseListener;
TutorialMouseMotionListener TheTutorialMouseMotionListener;
TutorialWindow->addMouseListener(&TheTutorialMouseListener);
TutorialWindow->addMouseMotionListener(&TheTutorialMouseMotionListener);
// Create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// Tell the Manager what to manage
mgr->setWindow(TutorialWindow);
BlendChunkRefPtr PSBlendChunk = BlendChunk::create();
PSBlendChunk->setSrcFactor(GL_SRC_ALPHA);
PSBlendChunk->setDestFactor(GL_ONE_MINUS_SRC_ALPHA);
//Particle System Material
MaterialChunkRefPtr PSMaterialChunkChunk = MaterialChunk::create();
PSMaterialChunkChunk->setAmbient(Color4f(0.3f,0.3f,0.3f,1.0f));
PSMaterialChunkChunk->setDiffuse(Color4f(0.7f,0.7f,0.7f,1.0f));
PSMaterialChunkChunk->setSpecular(Color4f(0.9f,0.9f,0.9f,1.0f));
PSMaterialChunkChunk->setColorMaterial(GL_AMBIENT_AND_DIFFUSE);
ChunkMaterialRefPtr PSMaterial = ChunkMaterial::create();
PSMaterial->addChunk(PSMaterialChunkChunk);
PSMaterial->addChunk(PSBlendChunk);
Distribution3DRefPtr PositionDistribution = createPositionDistribution();
Pnt3f PositionReturnValue;
//Particle System
ParticleSystemRefPtr ExampleParticleSystem = OSG::ParticleSystem::create();
for(UInt32 i(0) ; i<800 ; ++i)//controls how many particles are created
{
if(PositionDistribution != NULL)
{
PositionReturnValue = Pnt3f(PositionDistribution->generate());
}
ExampleParticleSystem->addParticle(
PositionReturnValue,
Vec3f(0.0f,0.0f,1.0f),
Color4f(1.0,0.0,0.0,1.0),
Vec3f(10.0,10.0,10.0),
-1,
Vec3f(0.0f,0.0f,0.0f), //Velocity
Vec3f(0.0f,0.0f,0.0f) //acceleration
);
}
ExampleParticleSystem->attachUpdateListener(TutorialWindow);
//Particle System Drawer
DiscParticleSystemDrawerRefPtr ExampleParticleSystemDrawer = OSG::DiscParticleSystemDrawer::create();
ExampleParticleSystemDrawer->setSegments(16);
ExampleParticleSystemDrawer->setCenterAlpha(1.0);
ExampleParticleSystemDrawer->setEdgeAlpha(0.0);
//Particle System Node
ParticleSystemCoreRefPtr ParticleNodeCore = OSG::ParticleSystemCore::create();
ParticleNodeCore->setSystem(ExampleParticleSystem);
ParticleNodeCore->setDrawer(ExampleParticleSystemDrawer);
ParticleNodeCore->setMaterial(PSMaterial);
NodeRefPtr ParticleNode = OSG::Node::create();
ParticleNode->setCore(ParticleNodeCore);
//AttractionNode
TransformRefPtr AttractionCore = OSG::Transform::create();
Matrix AttractTransform;
AttractTransform.setTranslate(0.0f, 0.0,0.0);
AttractionCore->setMatrix(AttractTransform);
NodeRefPtr AttractionNode = OSG::Node::create();
AttractionNode->setCore(AttractionCore);
// Make Main Scene Node and add the Torus
NodeRefPtr scene = OSG::Node::create();
scene->setCore(OSG::Group::create());
scene->addChild(ParticleNode);
scene->addChild(AttractionNode);
mgr->setRoot(scene);
// Show the whole Scene
//mgr->showAll();
mgr->getNavigator()->set(Pnt3f(0.0,0.0,500.0), Pnt3f(0.0,0.0,0.0), Vec3f(0.0,1.0,0.0));
mgr->getNavigator()->setMotionFactor(1.0f);
mgr->getCamera()->setNear(0.1f);
mgr->getCamera()->setFar(1000.0f);
DistanceAttractRepelParticleAffectorRefPtr ExampleDistanceAttractRepelParticleAffector = OSG::DistanceAttractRepelParticleAffector::create();
ExampleDistanceAttractRepelParticleAffector->setMinDistance(0.0);
ExampleDistanceAttractRepelParticleAffector->setMaxDistance(1000.0);
ExampleDistanceAttractRepelParticleAffector->setQuadratic(0.0);
ExampleDistanceAttractRepelParticleAffector->setLinear(100.0);
ExampleDistanceAttractRepelParticleAffector->setConstant(0.0);
ExampleDistanceAttractRepelParticleAffector->setParticleSystemNode(ParticleNode);
ExampleDistanceAttractRepelParticleAffector->setDistanceFromSource(DistanceAttractRepelParticleAffector::DISTANCE_FROM_NODE);
ExampleDistanceAttractRepelParticleAffector->setDistanceFromNode(AttractionNode);
ExampleParticleSystem->pushToAffectors(ExampleDistanceAttractRepelParticleAffector);
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"11DistanceAttractRepelParticleAffector");
//Enter main Loop
TutorialWindow->mainLoop();
osgExit();
return 0;
}
// Initialize GLUT & OpenSG and set up the scene
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
// Set up Window
TutorialWindow = createNativeWindow();
//Initialize Window
TutorialWindow->initWindow();
TutorialWindow->setDisplayCallback(display);
TutorialWindow->setReshapeCallback(reshape);
//Add Window Listener
TutorialKeyListener TheKeyListener;
TutorialWindow->addKeyListener(&TheKeyListener);
TutorialMouseListener TheTutorialMouseListener;
TutorialMouseMotionListener TheTutorialMouseMotionListener;
TutorialWindow->addMouseListener(&TheTutorialMouseListener);
TutorialWindow->addMouseMotionListener(&TheTutorialMouseMotionListener);
// Create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// Tell the Manager what to manage
mgr->setWindow(TutorialWindow);
//Setup the Animation
setupAnimation();
//Box Geometry
GeometryUnrecPtr BoxGeometry = makeBoxGeo(1.0,1.0,1.0,1,1,1);
BoxGeometry->setMaterial(TheBoxMaterial);
NodeUnrecPtr BoxGeometryNode = Node::create();
BoxGeometryNode->setCore(BoxGeometry);
//Make Box Node
NodeUnrecPtr BoxNode = Node::create();
TransformUnrecPtr BoxNodeTrans;
BoxNodeTrans = Transform::create();
BoxNode->setCore(BoxNodeTrans);
BoxNode->addChild(BoxGeometryNode);
//Make Main Scene Node
NodeUnrecPtr scene = Node::create();
ComponentTransformUnrecPtr Trans;
Trans = ComponentTransform::create();
scene->setCore(Trans);
// add the torus as a child
scene->addChild(BoxNode);
// tell the manager what to manage
mgr->setRoot (scene);
// show the whole scene
mgr->showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"05TextureAnimation");
//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);
// 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
TutorialWindowEventProducer = createDefaultWindowEventProducer();
WindowPtr MainWindow = TutorialWindowEventProducer->initWindow();
TutorialWindowEventProducer->setDisplayCallback(display);
TutorialWindowEventProducer->setReshapeCallback(reshape);
TutorialKeyListener TheKeyListener;
TutorialWindowEventProducer->addKeyListener(&TheKeyListener);
TutorialUpdateListener TheUpdateListener;
TutorialWindowEventProducer->addUpdateListener(&TheUpdateListener);
// Create the SceneManager
mgr = new SceneManager;
// Tell the Manager what to manage
mgr->setWindow(MainWindow);
// Make Torus Node (creates Torus in background of scene)
NodePtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Torus Node (creates Torus in background of scene)
NodePtr BoxGeometryNode = makeBox(0.5,0.5,0.5,50,2,2);
//Set the Camera Beacon Node
Matrix Offset;
//Offset.setTranslate(0.0f,2.5f,6.0f);
Offset.setTranslate(0.0f,0.0,6.0f);
CameraBeaconTransform = Transform::create();
beginEditCP(CameraBeaconTransform, Transform::MatrixFieldMask);
CameraBeaconTransform->setMatrix(Offset);
endEditCP(CameraBeaconTransform, Transform::MatrixFieldMask);
NodePtr CameraBeaconNode = Node::create();
beginEditCP(CameraBeaconNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
CameraBeaconNode->setCore(CameraBeaconTransform);
endEditCP(CameraBeaconNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
//Set the Box Transform Node
BoxTransform = Transform::create();
NodePtr BoxNode = Node::create();
beginEditCP(BoxNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
BoxNode->setCore(BoxTransform);
BoxNode->addChild(BoxGeometryNode);
BoxNode->addChild(CameraBeaconNode);
endEditCP(BoxNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
// Make Main Scene Node and add the Torus
NodePtr scene = osg::Node::create();
beginEditCP(scene, Node::CoreFieldMask | Node::ChildrenFieldMask);
scene->setCore(osg::Group::create());
scene->addChild(TorusGeometryNode);
scene->addChild(BoxNode);
endEditCP(scene, Node::CoreFieldMask | Node::ChildrenFieldMask);
//Set the Root node to the Scene Manager
mgr->setRoot(scene);
//The perspective decoratee camera
CameraPtr PCamera = PerspectiveCamera::create();
beginEditCP(PerspectiveCameraPtr::dcast(PCamera));
PerspectiveCameraPtr::dcast(PCamera)->setBeacon(CameraBeaconNode);
PerspectiveCameraPtr::dcast(PCamera)->setFov (deg2rad(60.f));
PerspectiveCameraPtr::dcast(PCamera)->setNear (0.1f);
PerspectiveCameraPtr::dcast(PCamera)->setFar (10000.f);
endEditCP(PerspectiveCameraPtr::dcast(PCamera));
//Create the Rubber band Camera
Vec3f PositionCoefficients(0.1,1.5,1.5);
Vec3f OrientationCoefficients(0.1,2.5,2.5);
RubberCamera = RubberBandCamera::create();
beginEditCP(RubberCamera, RubberBandCamera::DecorateeFieldMask | RubberBandCamera::BeaconFieldMask | RubberBandCamera::PositionCoefficientsFieldMask | RubberBandCamera::OrientationCoefficientsFieldMask);
RubberCamera->setDecoratee(PCamera);
RubberCamera->setBeacon(CameraBeaconNode);
RubberCamera->setPositionCoefficients(PositionCoefficients);
RubberCamera->setOrientationCoefficients(OrientationCoefficients);
endEditCP(RubberCamera, RubberBandCamera::DecorateeFieldMask | RubberBandCamera::BeaconFieldMask | RubberBandCamera::PositionCoefficientsFieldMask | RubberBandCamera::OrientationCoefficientsFieldMask);
RubberCamera->setToBeacon();
mgr->setCamera(RubberCamera);
// Show the whole Scene
//mgr->showAll();
//Open Window
Vec2f WinSize(TutorialWindowEventProducer->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindowEventProducer->getDesktopSize() - WinSize) *0.5);
TutorialWindowEventProducer->openWindow(WinPos,
WinSize,
"01RubberBandCamera");
//Enter main Loop
TutorialWindowEventProducer->mainLoop();
osgExit();
return 0;
}
// Initialize GLUT & OpenSG and set up the scene
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
getDefaultVideoManager()->init(argc, argv);
TheVideo = getDefaultVideoManager()->createVideoWrapper();
TutorialVideoListener TheVideoListener;
TheVideo->addVideoListener(&TheVideoListener);
//TheVideo->open(Path("./Data/ExampleVideo.avi"));
TheVideo->open(Path("./Data/ExampleVideo.avi"));
TheVideo->pause();
// GLUT init
int winid = setupGLUT(&argc, argv);
// the connection between GLUT and OpenSG
GLUTWindowPtr gwin= GLUTWindow::create();
gwin->setId(winid);
gwin->init();
// create the scene
TheVideo->updateImage();
Real32 AspectRatio(static_cast<Real32>(TheVideo->getImage()->getWidth())/static_cast<Real32>(TheVideo->getImage()->getHeight()));
MaterialPtr VideoMaterial = createVideoMaterial();
//Plane Geometry
GeometryPtr PlaneGeometry = makePlaneGeo(10.0*AspectRatio,10.0,10,10);
beginEditCP(PlaneGeometry, Geometry::MaterialFieldMask);
PlaneGeometry->setMaterial(VideoMaterial);
endEditCP(PlaneGeometry, Geometry::MaterialFieldMask);
NodePtr PlaneGeometryNode = Node::create();
beginEditCP(PlaneGeometryNode, Node::CoreFieldMask);
PlaneGeometryNode->setCore(PlaneGeometry);
endEditCP(PlaneGeometryNode, Node::CoreFieldMask);
//Box Geometry
GeometryPtr BoxGeometry = makeBoxGeo(10.0*AspectRatio,10.0,10.0,2,2,2);
beginEditCP(BoxGeometry, Geometry::MaterialFieldMask);
BoxGeometry->setMaterial(VideoMaterial);
endEditCP(BoxGeometry, Geometry::MaterialFieldMask);
NodePtr BoxGeometryNode = Node::create();
beginEditCP(BoxGeometryNode, Node::CoreFieldMask);
BoxGeometryNode->setCore(BoxGeometry);
endEditCP(BoxGeometryNode, Node::CoreFieldMask);
//Sphere Geometry
GeometryPtr SphereGeometry = makeSphereGeo(2,5.0);
beginEditCP(SphereGeometry, Geometry::MaterialFieldMask);
SphereGeometry->setMaterial(VideoMaterial);
endEditCP(SphereGeometry, Geometry::MaterialFieldMask);
NodePtr SphereGeometryNode = Node::create();
beginEditCP(SphereGeometryNode, Node::CoreFieldMask);
SphereGeometryNode->setCore(SphereGeometry);
endEditCP(SphereGeometryNode, Node::CoreFieldMask);
//Torus Geometry
GeometryPtr TorusGeometry = makeTorusGeo(2.0,5.0,32,32);
beginEditCP(TorusGeometry, Geometry::MaterialFieldMask);
TorusGeometry->setMaterial(VideoMaterial);
endEditCP(TorusGeometry, Geometry::MaterialFieldMask);
NodePtr TorusGeometryNode = Node::create();
beginEditCP(TorusGeometryNode, Node::CoreFieldMask);
TorusGeometryNode->setCore(TorusGeometry);
endEditCP(TorusGeometryNode, Node::CoreFieldMask);
//Switch Node
GeometryNodeSwitch = Switch::create();
beginEditCP(GeometryNodeSwitch, Switch::ChoiceFieldMask);
GeometryNodeSwitch->setChoice(0);
endEditCP(GeometryNodeSwitch, Switch::ChoiceFieldMask);
SwitchNode = Node::create();
beginEditCP(SwitchNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
SwitchNode->setCore(GeometryNodeSwitch);
SwitchNode->addChild(PlaneGeometryNode);
SwitchNode->addChild(BoxGeometryNode);
SwitchNode->addChild(SphereGeometryNode);
SwitchNode->addChild(TorusGeometryNode);
endEditCP(SwitchNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
NodePtr scene = Node::create();
trans = Transform::create();
beginEditCP(scene, Node::CoreFieldMask | Node::ChildrenFieldMask);
{
scene->setCore(trans);
scene->addChild(SwitchNode);
}
endEditCP (scene, Node::CoreFieldMask | Node::ChildrenFieldMask);
// To check OpenGL extensions, the Window needs to have run through
// frameInit at least once. This automatically happens when rendering,
// but we don't don't to wait for that here.
gwin->activate();
gwin->frameInit();
// Now we can check for OpenGL extensions
hasNPOT = gwin->hasExtension("GL_ARB_texture_rectangle");
// Print what we've got
SLOG << "Got " << (isPOT?"":"non-") << "power-of-two images and "
<< (hasNPOT?"can":"cannot") << " use NPOT textures, changing "
<< (changeOnlyPart?"part":"all")
<< " of the screen"
<< endLog;
// create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// tell the manager what to manage
mgr->setWindow(gwin );
mgr->setRoot (scene);
mgr->setStatistics(true);
// show the whole scene
mgr->showAll();
//Start playing video
TheVideo->play();
// GLUT main loop
glutMainLoop();
//DeInit
TheVideo->stop();
TheVideo->close();
getDefaultVideoManager()->exit();
osgExit();
return 0;
}
// Initialize GLUT & OpenSG and set up the scene
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
// GLUT init
int winid = setupGLUT(&argc, argv);
// the connection between GLUT and OpenSG
GLUTWindowPtr gwin= GLUTWindow::create();
gwin->setId(winid);
gwin->init();
// load the scene
if(argc < 2)
{
FWARNING(("No file given!\n"));
FWARNING(("Supported file formats:\n"));
std::list<const char*> suffixes;
SceneFileHandler::the().getSuffixList(suffixes);
for(std::list<const char*>::iterator it = suffixes.begin();
it != suffixes.end();
++it)
{
FWARNING(("%s\n", *it));
}
std::vector<std::string> suffixesVec;
suffixesVec = FCFileHandler::the()->getSuffixList();
for(std::vector<std::string>::iterator it = suffixesVec.begin();
it != suffixesVec.end();
++it)
{
FWARNING(("%s\n", *it));
}
RootNodes.push_back( makeTorus(.5, 2, 16, 16) );
glutSetWindowTitle("No file Loaded");
}
else
{
glutSetWindowTitle(argv[1]);
Load(std::string(argv[1]), RootNodes, Cameras);
if(RootNodes.size() < 1)
{
std::cout << "There are no root nodes defined." << std::endl;
return 0;
}
}
//Create Statistics Foreground
SimpleStatisticsForegroundPtr TheStatForeground = SimpleStatisticsForeground::create();
beginEditCP(TheStatForeground);
TheStatForeground->setSize(25);
TheStatForeground->setColor(Color4f(0,1,0,0.7));
TheStatForeground->addElement(RenderAction::statDrawTime, "Draw FPS: %r.3f");
TheStatForeground->addElement(DrawActionBase::statTravTime, "TravTime: %.3f s");
TheStatForeground->addElement(RenderAction::statDrawTime, "DrawTime: %.3f s");
TheStatForeground->addElement(DrawActionBase::statCullTestedNodes,
"%d Nodes culltested");
TheStatForeground->addElement(DrawActionBase::statCulledNodes,
"%d Nodes culled");
TheStatForeground->addElement(RenderAction::statNMaterials,
"%d material changes");
TheStatForeground->addElement(RenderAction::statNMatrices,
"%d matrix changes");
TheStatForeground->addElement(RenderAction::statNGeometries,
"%d Nodes drawn");
TheStatForeground->addElement(RenderAction::statNTransGeometries,
"%d transparent Nodes drawn");
TheStatForeground->addElement(Drawable::statNTriangles,
"%d triangles drawn");
TheStatForeground->addElement(Drawable::statNLines,
"%d lines drawn");
TheStatForeground->addElement(Drawable::statNPoints,
"%d points drawn");
TheStatForeground->addElement(Drawable::statNPrimitives,
"%d primitive groups drawn");
TheStatForeground->addElement(Drawable::statNVertices,
"%d vertices transformed");
TheStatForeground->addElement(Drawable::statNGeoBytes, "%d bytes of geometry used");
TheStatForeground->addElement(RenderAction::statNTextures, "%d textures used");
TheStatForeground->addElement(RenderAction::statNTexBytes, "%d bytes of texture used");
endEditCP(TheStatForeground);
//Set up Selection
SelectedRootNode = 0;
SelectedCamera = -1;
// create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// tell the manager what to manage
mgr->setWindow(gwin );
mgr->setRoot (RootNodes[SelectedRootNode]);
mgr->turnHeadlightOff();
beginEditCP(mgr->getWindow()->getPort(0), Viewport::ForegroundsFieldMask);
mgr->getWindow()->getPort(0)->getForegrounds().push_back(TheStatForeground);
endEditCP(mgr->getWindow()->getPort(0), Viewport::ForegroundsFieldMask);
StatCollector *collector = &TheStatForeground->getCollector();
// add optional elements
collector->getElem(Drawable::statNTriangles);
mgr->getAction()->setStatistics(collector);
// show the whole scene
mgr->showAll();
// GLUT main loop
glutMainLoop();
return 0;
}
int main(int argc, char **argv)
{
osgInit(argc,argv);
// GLUT init
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
glutCreateWindow("OpenSG");
glutReshapeFunc(reshape);
glutDisplayFunc(display);
glutIdleFunc(display);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutKeyboardFunc(keyboard);
PassiveWindowPtr pwin=PassiveWindow::create();
pwin->init();
// create the scene
NodePtr scene;
scene = Node::create();
// create the material
// Pass 1: Simple red, shiny, depth-tested
DepthChunkPtr cl1 = DepthChunk::create();
beginEditCP(cl1);
cl1->setEnable(true);
cl1->setFunc(GL_LEQUAL);
endEditCP(cl1);
SimpleMaterialPtr mat = SimpleMaterial::create();
beginEditCP(mat);
mat->setDiffuse(Color3f(1,0,0));
mat->setSpecular(Color3f(.9,.9,.9));
mat->setShininess(30);
mat->setLit(true);
mat->addChunk(cl1);
endEditCP(mat);
// Pass 2: Green unlit, without depth testing
DepthChunkPtr cl2 = DepthChunk::create();
beginEditCP(cl2);
cl2->setEnable(false);
endEditCP(cl2);
SimpleMaterialPtr mat2 = SimpleMaterial::create();
beginEditCP(mat2);
mat2->setDiffuse(Color3f(0,1,0));
mat2->setLit(false);
mat2->setTransparency(.8);
mat2->addChunk(cl2);
endEditCP(mat2);
// Bring them together
MultiPassMaterialPtr mpm = MultiPassMaterial::create();
beginEditCP(mpm);
mpm->editMFMaterials()->push_back(mat);
mpm->editMFMaterials()->push_back(mat2);
endEditCP(mpm);
GeometryPtr g1 = makeTorusGeo(0.2, 2, 8, 16);
beginEditCP(scene);
scene->setCore(g1);
endEditCP(scene);
beginEditCP(g1);
g1->setMaterial(mpm);
endEditCP(g1);
// create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// create the window and initial camera/viewport
mgr->setWindow(pwin );
// tell the manager what to manage
mgr->setRoot (scene);
// show the whole scene
mgr->showAll();
mgr->redraw();
// GLUT main loop
glutMainLoop();
return 0;
}
// Initialize GLUT & OpenSG and set up the scene
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
{
// Set up Window
TutorialWindow = createNativeWindow();
TutorialWindow->setDisplayCallback(display);
TutorialWindow->setReshapeCallback(reshape);
//Add Window Listener
TutorialKeyListener TheKeyListener;
TutorialWindow->addKeyListener(&TheKeyListener);
TutorialMouseListener TheTutorialMouseListener;
TutorialMouseMotionListener TheTutorialMouseMotionListener;
TutorialWindow->addMouseListener(&TheTutorialMouseListener);
TutorialWindow->addMouseMotionListener(&TheTutorialMouseMotionListener);
//Initialize Window
TutorialWindow->initWindow();
//Torus Material
TheTorusMaterial = SimpleMaterial::create();
dynamic_pointer_cast<SimpleMaterial>(TheTorusMaterial)->setAmbient(Color3f(0.2,0.2,0.2));
dynamic_pointer_cast<SimpleMaterial>(TheTorusMaterial)->setDiffuse(Color3f(0.7,0.7,0.7));
dynamic_pointer_cast<SimpleMaterial>(TheTorusMaterial)->setSpecular(Color3f(0.7,0.7,0.7));
dynamic_pointer_cast<SimpleMaterial>(TheTorusMaterial)->setShininess(100.0f);
//Torus Geometry
GeometryRefPtr TorusGeometry = makeTorusGeo(.5, 2, 32, 32);
TorusGeometry->setMaterial(TheTorusMaterial);
NodeRefPtr TorusGeometryNode = Node::create();
TorusGeometryNode->setCore(TorusGeometry);
//Make Torus Node
NodeRefPtr TorusNode = Node::create();
TorusNodeTrans = Transform::create();
setName(TorusNodeTrans, std::string("TorusNodeTransformationCore"));
TorusNode->setCore(TorusNodeTrans);
TorusNode->addChild(TorusGeometryNode);
//Make Main Scene Node
NodeRefPtr scene = Node::create();
Trans = ComponentTransform::create();
setName(Trans, std::string("MainTransformationCore"));
scene->setCore(Trans);
scene->addChild(TorusNode);
setupAnimation();
commitChanges();
// Create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// Tell the Manager what to manage
mgr->setWindow(TutorialWindow);
// tell the manager what to manage
mgr->setRoot (scene);
// show the whole scene
mgr->showAll();
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"OpenSG 02TransformAnimation Window");
//Enter main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
// 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();
// Create the SimpleSceneManager helper
SimpleSceneManager sceneManager;
TutorialWindow->setDisplayCallback(boost::bind(display, &sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, &sceneManager));
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
//Attach to events
TutorialWindow->connectMousePressed(boost::bind(mousePressed, _1, &sceneManager));
TutorialWindow->connectMouseReleased(boost::bind(mouseReleased, _1, &sceneManager));
TutorialWindow->connectMouseMoved(boost::bind(mouseMoved, _1, &sceneManager));
TutorialWindow->connectMouseDragged(boost::bind(mouseDragged, _1, &sceneManager));
TutorialWindow->connectMouseWheelMoved(boost::bind(mouseWheelMoved, _1, &sceneManager));
TutorialWindow->connectKeyReleased(boost::bind(keyReleased, _1));
//Make Main Scene Node
NodeRefPtr scene = makeCoredNode<Group>();
setName(scene, "scene");
NodeRecPtr rootNode = Node::create();
setName(rootNode, "rootNode");
ComponentTransformRefPtr Trans = ComponentTransform::create();
rootNode->setCore(Trans);
rootNode->addChild(scene);
//Light Beacon
Matrix LightTransformMat;
LightTransformMat.setTranslate(Vec3f(50.0,0.0,100.0));
TransformRefPtr LightTransform = Transform::create();
LightTransform->setMatrix(LightTransformMat);
NodeRefPtr TutorialLightBeacon = Node::create();
TutorialLightBeacon->setCore(LightTransform);
//Light Node
PointLightRefPtr TutorialLight = PointLight::create();
TutorialLight->setBeacon(TutorialLightBeacon);
NodeRefPtr TutorialLightNode = Node::create();
TutorialLightNode->setCore(TutorialLight);
scene->addChild(TutorialLightNode);
scene->addChild(TutorialLightBeacon);
//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();
//Setup the default collision parameters
CollisionContactParametersRefPtr DefaultCollisionParams = CollisionContactParameters::createEmpty();
DefaultCollisionParams->setMode(dContactApprox1);
DefaultCollisionParams->setMu(1.0);
DefaultCollisionParams->setMu2(0.0);
DefaultCollisionParams->setBounce(0.0);
DefaultCollisionParams->setBounceSpeedThreshold(0.0);
DefaultCollisionParams->setSoftCFM(0.1);
DefaultCollisionParams->setSoftERP(0.2);
DefaultCollisionParams->setMotion1(0.0);
DefaultCollisionParams->setMotion2(0.0);
DefaultCollisionParams->setMotionN(0.0);
DefaultCollisionParams->setSlip1(0.0);
DefaultCollisionParams->setSlip2(0.0);
physicsSpace->setDefaultCollisionParameters(DefaultCollisionParams);
PhysicsHandlerRecPtr physHandler = PhysicsHandler::create();
physHandler->setWorld(physicsWorld);
physHandler->pushToSpaces(physicsSpace);
physHandler->setUpdateNode(rootNode);
physHandler->attachUpdateProducer(TutorialWindow);
rootNode->addAttachment(physHandler);
rootNode->addAttachment(physicsWorld);
rootNode->addAttachment(physicsSpace);
/************************************************************************/
/* create spaces, geoms and bodys */
/************************************************************************/
//create a group for our space
GroupRefPtr spaceGroup;
NodeRecPtr spaceGroupNode = makeCoredNode<Group>(&spaceGroup);
//create the ground terrain
GeometryRefPtr TerrainGeo = buildTerrain(Vec2f(400.0,400.0),25,25);
//and its Material
SimpleMaterialRefPtr TerrainMat = SimpleMaterial::create();
TerrainMat->setAmbient(Color3f(0.3,0.5,0.3));
TerrainMat->setDiffuse(Color3f(0.5,0.9,0.5));
TerrainGeo->setMaterial(TerrainMat);
NodeRefPtr TerrainNode = Node::create();
TerrainNode->setCore(TerrainGeo);
//create ODE data
PhysicsGeomRefPtr TerrainODEGeom = PhysicsTriMeshGeom::create();
//add geom to space for collision
TerrainODEGeom->setSpace(physicsSpace);
//set the geometryNode to fill the ode-triMesh
dynamic_pointer_cast<PhysicsTriMeshGeom>(TerrainODEGeom)->setGeometryNode(TerrainNode);
//add attachments
//add Attachments to nodes...
spaceGroupNode->addAttachment(physicsSpace);
spaceGroupNode->addChild(TerrainNode);
TerrainNode->addAttachment(TerrainODEGeom);
TutorialLightNode->addChild(spaceGroupNode);
//Create Character
PhysicsBodyRefPtr CharacterPhysicsBody = buildCharacter(Vec3f(5.0,5.0,10.0),
Pnt3f((Real32)(rand()%100)-50.0,(Real32)(rand()%100)-50.0,25.0),
spaceGroupNode,
physicsWorld,
physicsSpace);
PhysicsLMotorJointRefPtr CharacterMover = buildMover(CharacterPhysicsBody);
TutorialWindow->connectKeyPressed(boost::bind(keyPressed, _1,
spaceGroupNode.get(),
physicsWorld.get(),
physicsSpace.get()));
TutorialWindow->connectUpdate(boost::bind(handleUpdate, _1,
CharacterPhysicsBody.get(),
CharacterMover.get()));
// tell the manager what to manage
sceneManager.setRoot (rootNode);
// show the whole rootNode
sceneManager.showAll();
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"03CharacterTerrain");
//Enter main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
// Set up Window
TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
TutorialWindow->setDisplayCallback(display);
TutorialWindow->setReshapeCallback(reshape);
TutorialKeyListener TheKeyListener;
TutorialWindow->addKeyListener(&TheKeyListener);
// 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();
/******************************************************
Creates some Button components
******************************************************/
ButtonRefPtr ExampleButton1 = OSG::Button::create();
ButtonRefPtr ExampleButton2 = OSG::Button::create();
ButtonRefPtr ExampleButton3 = OSG::Button::create();
ButtonRefPtr ExampleButton4 = OSG::Button::create();
ButtonRefPtr ExampleButton5 = OSG::Button::create();
ButtonRefPtr ExampleButton6 = OSG::Button::create();
/******************************************************
Create SpringLayout. 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: SpringLayout has no options which
can be set.
******************************************************/
SpringLayoutRefPtr MainInternalWindowLayout = OSG::SpringLayout::create();
// OverlayLayout has no options to edit!
// NOTHING : )
/******************************************************
Create and edit some Button Components.
******************************************************/
ExampleButton1->setPreferredSize(Vec2f(50,50));
ExampleButton1->setText("Button 1");
ExampleButton2->setPreferredSize(Vec2f(50,50));
ExampleButton2->setText("Button 2");
ExampleButton3->setPreferredSize(Vec2f(50,50));
ExampleButton3->setText("Button 3");
ExampleButton4->setPreferredSize(Vec2f(50,50));
ExampleButton4->setText("Button 4");
ExampleButton5->setPreferredSize(Vec2f(50,50));
ExampleButton5->setText("Button 5");
ExampleButton6->setPreferredSize(Vec2f(50,50));
ExampleButton6->setText("Button 6");
InternalWindowRefPtr MainInternalWindow = OSG::InternalWindow::create();
// SpringLayoutConstraints Information
// It is possible to set the constraint for the Y_EDGE, X_EDGE, BASELINE_EDGE, NORTH_EDGE, SOUTH_EDGE, EAST_EDGE, WEST_EDGE, HEIGHT_EDGE, and/or WIDTH_EDGE of a component.
// It is possible to constrain a component's edge x pixels above, below, to the right of, or to the left of the edges other components, frames, and/or the MainInternalWindow.
// It is possible to constrain a component to the Y_EDGE, X_EDGE, BASELINE_EDGE, NORTH_EDGE, SOUTH_EDGE, EAST_EDGE, WEST_EDGE, HORIZONTAL_CENTER_EDGE, VERTICAL_CENTER_EDGE, HEIGHT_EDGE, and/or WIDTH_EDGE of whatever component to which it is constrained.
//Example Button 1
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::NORTH_EDGE, ExampleButton1, 25, SpringLayoutConstraints::NORTH_EDGE, MainInternalWindow); // The North edge of ExampleButton1 is 25 pixels below the North edge of the MainInternalWindow.
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::SOUTH_EDGE, ExampleButton1, -5, SpringLayoutConstraints::VERTICAL_CENTER_EDGE, MainInternalWindow); // The South edge of ExampleButton1 is 5 pixels above the Vertical Center of the MainInternalWindow.
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::EAST_EDGE, ExampleButton1, -25, SpringLayoutConstraints::EAST_EDGE, MainInternalWindow); // The East edge of ExampleButton1 is 25 pixels to the left of the East edge of the MainInternalWindow.
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::WEST_EDGE, ExampleButton1, 25, SpringLayoutConstraints::WEST_EDGE, MainInternalWindow); // The West edge of ExampleButton1 is 25 pixels to the right of the West edge of the MainInternalWindow.
//Example Button 2
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::HEIGHT_EDGE, ExampleButton2, LayoutSpring::height(ExampleButton2)); // The Height edge of ExampleButton2 is set to the height of ExampleButton2.
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::SOUTH_EDGE, ExampleButton2, -25, SpringLayoutConstraints::SOUTH_EDGE, MainInternalWindow); // The South edge of ExampleButton2 is 25 pixels above the South edge of the MainInternalWindow.
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::EAST_EDGE, ExampleButton2, -5, SpringLayoutConstraints::HORIZONTAL_CENTER_EDGE, MainInternalWindow); // The East edge of ExampleButton2 is 5 pixels to the left of the Horizontal Center of the MainInternalWindow.
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::WEST_EDGE, ExampleButton2, 25, SpringLayoutConstraints::WEST_EDGE, MainInternalWindow); // The West edge of ExampleButton2 is 25 pixels to the right of the West edge of the MainInternalWindow.
//Example Button 3
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::HEIGHT_EDGE, ExampleButton3, LayoutSpring::height(ExampleButton3)); // The Height edge of ExampleButton3 is set to the height of ExampleButton3.
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::SOUTH_EDGE, ExampleButton3, -25, SpringLayoutConstraints::SOUTH_EDGE, MainInternalWindow); // The South edge of ExampleButton3 is 25 pixels above the South edge of the MainInternalWindow.
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::WEST_EDGE, ExampleButton3, 5, SpringLayoutConstraints::HORIZONTAL_CENTER_EDGE, MainInternalWindow); // The West edge of ExampleButton3 is 5 pixels to the right of the Horizontal Center of the MainInternalWindow.
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::EAST_EDGE, ExampleButton3, -25, SpringLayoutConstraints::EAST_EDGE, MainInternalWindow); // The East edge of ExampleButton3 is 25 pixels to the left of the East edge of the MainInternalWindow.
//Example Button 4
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::NORTH_EDGE, ExampleButton4, 25, SpringLayoutConstraints::SOUTH_EDGE, ExampleButton1); // The North edge of ExampleButton4 is 25 pixels below the South edge of ExampleButton1.
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::SOUTH_EDGE, ExampleButton4, -25, SpringLayoutConstraints::NORTH_EDGE, ExampleButton2); // The South edge of ExampleButton4 is 25 pixels above the North edge of ExampleButton2.
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::WEST_EDGE, ExampleButton4, 25, SpringLayoutConstraints::WEST_EDGE, MainInternalWindow); // The West edge of ExampleButton4 is 25 pixels to the right of the West edge of the MainInternalWindow.
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::EAST_EDGE, ExampleButton4, -100, SpringLayoutConstraints::HORIZONTAL_CENTER_EDGE, MainInternalWindow); // The East edge of ExampleButton4 is 100 pixels to the left of the Horizontal Center of the MainInternalWindow.
//Example Button 5
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::NORTH_EDGE, ExampleButton5, 25, SpringLayoutConstraints::SOUTH_EDGE, ExampleButton1); // The North edge of ExampleButton5 is 25 pixels below the South edge of ExampleButton1.
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::HEIGHT_EDGE, ExampleButton5, 0, SpringLayoutConstraints::HEIGHT_EDGE, ExampleButton4); // The Height of ExampleButton5 is set to the Height of ExampleButton4.
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::EAST_EDGE, ExampleButton5, 75, SpringLayoutConstraints::HORIZONTAL_CENTER_EDGE, MainInternalWindow); // The East edge of ExampleButton5 is 75 pixels to the right of the Horizontal Center of the MainInternalWindow.
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::WEST_EDGE, ExampleButton5, -75, SpringLayoutConstraints::HORIZONTAL_CENTER_EDGE, MainInternalWindow); // The West edge of ExampleButton5 is 75 pixels to the left of the Horizontal Center of the MainInternalWindow.
//Example Button 6
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::NORTH_EDGE, ExampleButton6, 25, SpringLayoutConstraints::SOUTH_EDGE, ExampleButton1); // The North edge of ExampleButton6 is 25 pixels below the South edge of ExampleButton1.
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::SOUTH_EDGE, ExampleButton6, -25, SpringLayoutConstraints::NORTH_EDGE, ExampleButton2); // The South edge of ExampleButton6 is 25 pixels above the North edge of ExampleButton2.
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::WEST_EDGE, ExampleButton6, 100, SpringLayoutConstraints::HORIZONTAL_CENTER_EDGE, MainInternalWindow); // The West edge of ExampleButton6 is 100 pixels to the right of the Horizontal Center of the MainInternalWindow.
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::WIDTH_EDGE, ExampleButton6, 0, SpringLayoutConstraints::WIDTH_EDGE, ExampleButton4); // The Width of ExampleButton6 is set to the Width of ExampleButton4.
// 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));
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
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);
// Create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// Tell the Manager what to manage
mgr->setWindow(TutorialWindow);
mgr->setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRefPtr TutorialViewport = mgr->getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
// Show the whole Scene
mgr->showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"36SpringLayout");
//Enter main Loop
TutorialWindow->mainLoop();
osgExit();
return 0;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
// Set up Window
TutorialWindowEventProducer = createDefaultWindowEventProducer();
WindowPtr MainWindow = TutorialWindowEventProducer->initWindow();
TutorialWindowEventProducer->setDisplayCallback(display);
TutorialWindowEventProducer->setReshapeCallback(reshape);
TutorialKeyListener TheKeyListener;
TutorialWindowEventProducer->addKeyListener(&TheKeyListener);
TutorialUpdateListener TheTutorialUpdateListener;
TutorialWindowEventProducer->addUpdateListener(&TheTutorialUpdateListener);
// Create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// Tell the Manager what to manage
mgr->setWindow(MainWindow);
// Make Torus Node (creates Torus in background of scene)
NodePtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
scene = osg::Node::create();
beginEditCP(scene, Node::CoreFieldMask | Node::ChildrenFieldMask);
scene->setCore(osg::Group::create());
scene->addChild(TorusGeometryNode);
endEditCP(scene, Node::CoreFieldMask | Node::ChildrenFieldMask);
// Create the Graphics
GraphicsPtr TutorialGraphics = osg::Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
DefaultDialogComponentGeneratorPtr TutorialDialogGenerator = DefaultDialogComponentGenerator::create();
ButtonFont = osg::UIFont::create();
beginEditCP(ButtonFont, UIFont::SizeFieldMask);
ButtonFont->setSize(16);
endEditCP(ButtonFont, UIFont::SizeFieldMask);
ButtonPtr Response = osg::Button::create();
beginEditCP(Response, Button::MinSizeFieldMask | Button::MaxSizeFieldMask | Button::PreferredSizeFieldMask | Button::ToolTipTextFieldMask | Button::TextFieldMask |
Button::FontFieldMask | Button::TextColorFieldMask | Button::RolloverTextColorFieldMask | Button::ActiveTextColorFieldMask );
Response->setMinSize(Vec2f(50, 25));
Response->setMaxSize(Vec2f(200, 100));
Response->setPreferredSize(Vec2f(100, 50));
Response->setToolTipText("These buttons are for selecting a response!");
Response->setFont(ButtonFont);
Response->setTextColor(Color4f(1.0, 0.0, 0.0, 1.0));
Response->setRolloverTextColor(Color4f(1.0, 0.0, 1.0, 1.0));
Response->setActiveTextColor(Color4f(1.0, 0.0, 0.0, 1.0));
endEditCP(Response, Button::MinSizeFieldMask | Button::MaxSizeFieldMask | Button::PreferredSizeFieldMask | Button::ToolTipTextFieldMask | Button::TextFieldMask |
Button::FontFieldMask | Button::TextColorFieldMask | Button::RolloverTextColorFieldMask | Button::ActiveTextColorFieldMask );
LabelPtr LabelPrototype = Label::create();
LabelPrototype->setAlignment(Pnt2f(0.5f,0.5f));
LabelPrototype->setPreferredSize(Pnt2f(250.0,30.0));
DialogInterfacePtr TutorialDialogInterface = osg::DialogInterface::create();
beginEditCP(TutorialDialogGenerator, DefaultDialogComponentGenerator::ResponseButtonPrototypeFieldMask | DefaultDialogComponentGenerator::QuestionPrototypeFieldMask);
TutorialDialogGenerator->setResponseButtonPrototype(Response);
TutorialDialogGenerator->setQuestionPrototype(LabelPrototype);
endEditCP(TutorialDialogGenerator, DefaultDialogComponentGenerator::ResponseButtonPrototypeFieldMask | DefaultDialogComponentGenerator::QuestionPrototypeFieldMask);
TutorialDialog = osg::DialogHierarchy::create();
beginEditCP(TutorialDialog, DialogHierarchy::DualNodeStyleFieldMask);
TutorialDialog->setDualNodeStyle(true);
endEditCP(TutorialDialog, DialogHierarchy::DualNodeStyleFieldMask);
DialogPtr rootDialog = TutorialDialog->addDialog("Which do you prefer?", 0.0, NullFC, true, NullFC);
DialogPtr RootDialogChildA = TutorialDialog->addDialog("Foreground", 0.0, NullFC, false, rootDialog);
DialogPtr RootDialogChildB = TutorialDialog->addDialog("Background", 0.0, NullFC, false, rootDialog);
DialogPtr SelectableDialogChildA = TutorialDialog->addDialog("What color would you like the forground to be?", 0.0, NullFC, true, RootDialogChildA);
DialogPtr SelectableDialogChildB = TutorialDialog->addDialog("What object do you want to be in the background?", 0.0, NullFC, true, RootDialogChildB);
ADialogChildA = TutorialDialog->addDialog("Blue", 0.0, NullFC, false, SelectableDialogChildA);
ADialogChildB = TutorialDialog->addDialog("Red", 0.0, NullFC, false, SelectableDialogChildA);
BDialogChildA = TutorialDialog->addDialog("Square", 0.0, NullFC, false, SelectableDialogChildB);
BDialogChildB = TutorialDialog->addDialog("Sphere", 0.0, NullFC, false, SelectableDialogChildB);
DialogPtr RestartEnd1 = TutorialDialog->addDialog("What would you like to do?", 0.0, NullFC, true, ADialogChildA);
DialogPtr RestartEnd2 = TutorialDialog->addDialog("What would you like to do?", 0.0, NullFC, true, ADialogChildB);
DialogPtr RestartEnd3 = TutorialDialog->addDialog("What would you like to do?", 0.0, NullFC, true, BDialogChildA);
DialogPtr RestartEnd4 = TutorialDialog->addDialog("What would you like to do?", 0.0, NullFC, true, BDialogChildB);
Restart1 = TutorialDialog->addDialog("Restart", 0.0, NullFC, false, RestartEnd1);
End1 = TutorialDialog->addDialog("End", 0.0, NullFC, false, RestartEnd1);
Restart2 = TutorialDialog->addDialog("Restart", 0.0, NullFC, false, RestartEnd2);
End2 = TutorialDialog->addDialog("End", 0.0, NullFC, false, RestartEnd2);
Restart3 = TutorialDialog->addDialog("Restart", 0.0, NullFC, false, RestartEnd3);
End3 = TutorialDialog->addDialog("End", 0.0, NullFC, false, RestartEnd3);
Restart4 = TutorialDialog->addDialog("Restart", 0.0, NullFC, false, RestartEnd4);
End4 = TutorialDialog->addDialog("End", 0.0, NullFC, false, RestartEnd4);
TutorialDialogListener TheTutorialDialogListener;
rootDialog->addDialogListener(&TheTutorialDialogListener);
RootDialogChildA->addDialogListener(&TheTutorialDialogListener);
RootDialogChildB->addDialogListener(&TheTutorialDialogListener);
ADialogChildA->addDialogListener(&TheTutorialDialogListener);
ADialogChildB->addDialogListener(&TheTutorialDialogListener);
BDialogChildA->addDialogListener(&TheTutorialDialogListener);
BDialogChildB->addDialogListener(&TheTutorialDialogListener);
Restart1->addDialogListener(&TheTutorialDialogListener);
End1->addDialogListener(&TheTutorialDialogListener);
Restart2->addDialogListener(&TheTutorialDialogListener);
End2->addDialogListener(&TheTutorialDialogListener);
Restart3->addDialogListener(&TheTutorialDialogListener);
End3->addDialogListener(&TheTutorialDialogListener);
Restart4->addDialogListener(&TheTutorialDialogListener);
End4->addDialogListener(&TheTutorialDialogListener);
SelectableDialogChildA->addDialogListener(&TheTutorialDialogListener);
SelectableDialogChildB->addDialogListener(&TheTutorialDialogListener);
RestartEnd1->addDialogListener(&TheTutorialDialogListener);
RestartEnd2->addDialogListener(&TheTutorialDialogListener);
RestartEnd3->addDialogListener(&TheTutorialDialogListener);
RestartEnd4->addDialogListener(&TheTutorialDialogListener);
LayoutPtr MainInternalWindowLayout = osg::FlowLayout::create();
// Create The Main InternalWindow
// Create Background to be used with the Main InternalWindow
MainInternalWindowBackground = osg::ColorLayer::create();
MainInternalWindow = osg::InternalWindow::create();
beginEditCP(MainInternalWindowBackground, ColorLayer::ColorFieldMask);
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
endEditCP(MainInternalWindowBackground, ColorLayer::ColorFieldMask);
beginEditCP(MainInternalWindow, InternalWindow::ChildrenFieldMask | InternalWindow::LayoutFieldMask | InternalWindow::BackgroundsFieldMask | InternalWindow::AlignmentInDrawingSurfaceFieldMask | InternalWindow::ScalingInDrawingSurfaceFieldMask | InternalWindow::DrawTitlebarFieldMask | InternalWindow::ResizableFieldMask);
MainInternalWindow->setLayout(MainInternalWindowLayout);
MainInternalWindow->setBackgrounds(MainInternalWindowBackground);
MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setScalingInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setDrawTitlebar(false);
MainInternalWindow->setResizable(false);
endEditCP(MainInternalWindow, InternalWindow::ChildrenFieldMask | InternalWindow::LayoutFieldMask | InternalWindow::BackgroundsFieldMask | InternalWindow::AlignmentInDrawingSurfaceFieldMask | InternalWindow::ScalingInDrawingSurfaceFieldMask | InternalWindow::DrawTitlebarFieldMask | InternalWindow::ResizableFieldMask);
beginEditCP(TutorialDialogInterface, DialogInterface::ComponentGeneratorFieldMask | DialogInterface::ParentContainerFieldMask | DialogInterface::SourceDialogHierarchyFieldMask);
TutorialDialogInterface->setComponentGenerator(TutorialDialogGenerator);
TutorialDialogInterface->setParentContainer(MainInternalWindow);
TutorialDialogInterface->setSourceDialogHierarchy(TutorialDialog);
endEditCP(TutorialDialogInterface, DialogInterface::ComponentGeneratorFieldMask | DialogInterface::ParentContainerFieldMask | DialogInterface::SourceDialogHierarchyFieldMask);
// Create the Drawing Surface
UIDrawingSurfacePtr TutorialDrawingSurface = UIDrawingSurface::create();
beginEditCP(TutorialDrawingSurface, UIDrawingSurface::GraphicsFieldMask | UIDrawingSurface::EventProducerFieldMask);
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindowEventProducer);
endEditCP(TutorialDrawingSurface, UIDrawingSurface::GraphicsFieldMask | UIDrawingSurface::EventProducerFieldMask);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundPtr TutorialUIForeground = osg::UIForeground::create();
beginEditCP(TutorialUIForeground, UIForeground::DrawingSurfaceFieldMask);
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
endEditCP(TutorialUIForeground, UIForeground::DrawingSurfaceFieldMask);
mgr->setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportPtr TutorialViewport = mgr->getWindow()->getPort(0);
beginEditCP(TutorialViewport, Viewport::ForegroundsFieldMask);
TutorialViewport->getForegrounds().push_back(TutorialUIForeground);
beginEditCP(TutorialViewport, Viewport::ForegroundsFieldMask);
// Show the whole Scene
mgr->showAll();
SoundManager::the()->setCamera(mgr->getCamera());
TutorialDialog->start();
Vec2f WinSize(TutorialWindowEventProducer->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindowEventProducer->getDesktopSize() - WinSize) *0.5);
TutorialWindowEventProducer->openWindow(WinPos,
WinSize,
"07DialogTypeTwo");
//Enter main Loop
TutorialWindowEventProducer->mainLoop();
osgExit();
return 0;
}
int main(int argc, char *argv[])
{
osgLogP->setLogLevel(LOG_NOTICE);
osgInit(argc, argv);
int winid = setupGLUT(&argc, argv);
// create a GLUT window
GLUTWindowPtr gwin = GLUTWindow::create();
gwin->setId(winid);
gwin->init();
osgLogP->setLogLevel(LOG_DEBUG);
// build the test scene
NodePtr pRoot = Node ::create();
GroupPtr pRootCore = Group::create();
NodePtr pRayGeo = Node ::create();
NodePtr pScene = buildGraph();
GroupPtr pSceneCore = Group::create();
Time tStart;
Time tStop;
Time tDFTotal = 0.0;
Time tDFSTotal = 0.0;
Time tPTotal = 0.0;
Time tOTotal = 0.0;
StatCollector statP;
StatCollector statDF;
StatCollector statDFS;
beginEditCP(pRoot, Node::CoreFieldId | Node::ChildrenFieldId);
pRoot->setCore (pRootCore );
pRoot->addChild(pScene );
pRoot->addChild(pRayGeo );
endEditCP (pRoot, Node::CoreFieldId | Node::ChildrenFieldId);
createRays(uiNumRays, testRays);
// build the geometry to visualize the rays
pPoints = GeoPositions3f::create();
beginEditCP(pPoints);
pPoints->addValue(Pnt3f(0.0, 0.0, 0.0));
pPoints->addValue(Pnt3f(0.0, 0.0, 0.0));
pPoints->addValue(Pnt3f(0.0, 0.0, 0.0));
pPoints->addValue(Pnt3f(0.0, 0.0, 0.0));
pPoints->addValue(Pnt3f(0.0, 0.0, 0.0));
endEditCP (pPoints);
GeoIndicesUI32Ptr pIndices = GeoIndicesUI32::create();
beginEditCP(pIndices);
pIndices->addValue(0);
pIndices->addValue(1);
pIndices->addValue(2);
pIndices->addValue(3);
pIndices->addValue(4);
endEditCP (pIndices);
GeoPLengthsPtr pLengths = GeoPLengthsUI32::create();
beginEditCP(pLengths);
pLengths->addValue(2);
pLengths->addValue(3);
endEditCP (pLengths);
GeoPTypesPtr pTypes = GeoPTypesUI8::create();
beginEditCP(pTypes);
pTypes->addValue(GL_LINES );
pTypes->addValue(GL_TRIANGLES);
endEditCP (pTypes);
GeoColors3fPtr pColors = GeoColors3f::create();
beginEditCP(pColors);
pColors->addValue(Color3f(1.0, 1.0, 1.0));
pColors->addValue(Color3f(1.0, 0.0, 0.0));
pColors->addValue(Color3f(1.0, 0.0, 0.0));
pColors->addValue(Color3f(1.0, 0.0, 0.0));
pColors->addValue(Color3f(1.0, 0.0, 0.0));
endEditCP (pColors);
SimpleMaterialPtr pMaterial = SimpleMaterial::create();
beginEditCP(pMaterial);
pMaterial->setLit(false);
endEditCP (pMaterial);
GeometryPtr pRayGeoCore = Geometry::create();
beginEditCP(pRayGeoCore);
pRayGeoCore->setPositions(pPoints );
pRayGeoCore->setIndices (pIndices );
pRayGeoCore->setLengths (pLengths );
pRayGeoCore->setTypes (pTypes );
pRayGeoCore->setColors (pColors );
pRayGeoCore->setMaterial (pMaterial);
endEditCP (pRayGeoCore);
beginEditCP(pRayGeo, Node::CoreFieldId);
pRayGeo->setCore(pRayGeoCore);
endEditCP (pRayGeo, Node::CoreFieldId);
IntersectActor::regDefaultClassEnter(
osgTypedFunctionFunctor2CPtr<
NewActionTypes::ResultE, NodeCorePtr,
ActorBase::FunctorArgumentType & >(enterDefault));
NewActionBase *pDFAction = DepthFirstAction ::create();
NewActionBase *pDFSAction = DepthFirstStateAction::create();
NewActionBase *pPAction = PriorityAction ::create();
IntersectActor *pIActorDF = IntersectActor ::create();
IntersectActor *pIActorDFS = IntersectActor ::create();
IntersectActor *pIActorP = IntersectActor ::create();
pDFAction ->setStatistics(&statDF );
pDFSAction->setStatistics(&statDFS);
pPAction ->setStatistics(&statP );
// IntersectActor with DFS-Action does not need leave calls
pIActorDFS->setLeaveNodeFlag(false);
pDFAction ->addActor(pIActorDF );
pDFSAction->addActor(pIActorDFS);
pPAction ->addActor(pIActorP );
// create old action
IntersectAction *pIntAction = IntersectAction ::create();
// make sure bv are up to date
pScene->updateVolume();
SINFO << "-=< Intersect >=-" << endLog;
std::vector<Line>::iterator itRays = testRays.begin();
std::vector<Line>::iterator endRays = testRays.end ();
for(; itRays != endRays; ++itRays)
{
// DepthFirst
tStart = getSystemTime();
pIActorDF->setRay (*itRays);
pIActorDF->setMaxDistance(10000.0);
pIActorDF->reset ( );
pDFAction->apply(pScene);
tStop = getSystemTime();
tDFTotal += (tStop - tStart);
if(pIActorDF->getHit() == true)
{
IntersectResult result;
result._hit = true;
result._pObj = pIActorDF->getHitObject ();
result._tri = pIActorDF->getHitTriangleIndex();
result._dist = pIActorDF->getHitDistance ();
result._time = (tStop - tStart);
resultsDF.push_back(result);
}
else
{
IntersectResult result;
result._hit = false;
result._pObj = NullFC;
result._tri = -1;
result._dist = 0.0;
result._time = (tStop - tStart);
resultsDF.push_back(result);
}
std::string strStatDF;
statDF.putToString(strStatDF);
//SINFO << "stat DF: " << strStatDF << endLog;
// Depth First State
tStart = getSystemTime();
pIActorDFS->setRay (*itRays);
pIActorDFS->setMaxDistance(10000.0);
pIActorDFS->reset ( );
pDFSAction->apply(pScene);
tStop = getSystemTime();
tDFSTotal += (tStop - tStart);
if(pIActorDFS->getHit() == true)
{
IntersectResult result;
result._hit = true;
result._pObj = pIActorDFS->getHitObject ();
result._tri = pIActorDFS->getHitTriangleIndex();
result._dist = pIActorDFS->getHitDistance ();
result._time = (tStop - tStart);
resultsDFS.push_back(result);
}
else
{
IntersectResult result;
result._hit = false;
result._pObj = NullFC;
result._tri = -1;
result._dist = 0.0;
result._time = (tStop - tStart);
resultsDFS.push_back(result);
}
std::string strStatDFS;
statDFS.putToString(strStatDFS);
//SINFO << "stat DFS: " << strStatDFS << endLog;
// Priority
tStart = getSystemTime();
pIActorP->setRay (*itRays);
pIActorP->setMaxDistance(10000.0);
pIActorP->reset ( );
pPAction->apply(pScene);
tStop = getSystemTime();
tPTotal += (tStop - tStart);
if(pIActorP->getHit() == true)
{
IntersectResult result;
result._hit = true;
result._pObj = pIActorP->getHitObject ();
result._tri = pIActorP->getHitTriangleIndex();
result._dist = pIActorP->getHitDistance ();
result._time = (tStop - tStart);
resultsP.push_back(result);
}
else
{
IntersectResult result;
result._hit = false;
result._pObj = NullFC;
result._tri = -1;
result._dist = 0.0;
result._time = (tStop - tStart);
resultsP.push_back(result);
}
std::string strStatP;
statP.putToString(strStatP);
//SINFO << "stat P: " << strStatP << endLog;
// Old
tStart = getSystemTime();
pIntAction->setLine(*itRays, 100000);
pIntAction->apply (pScene );
tStop = getSystemTime();
tOTotal += (tStop - tStart);
if(pIntAction->didHit() == true)
{
IntersectResult result;
result._hit = true;
result._pObj = pIntAction->getHitObject ();
result._tri = pIntAction->getHitTriangle();
result._dist = pIntAction->getHitT ();
result._time = (tStop - tStart);
resultsO.push_back(result);
}
else
{
IntersectResult result;
result._hit = false;
result._pObj = NullFC;
result._tri = -1;
result._dist = 0.0;
result._time = (tStop - tStart);
resultsO.push_back(result);
}
}
UInt32 DFwins = 0;
UInt32 DFwinsHit = 0;
UInt32 DFwinsMiss = 0;
UInt32 DFSwins = 0;
UInt32 DFSwinsHit = 0;
UInt32 DFSwinsMiss = 0;
UInt32 Pwins = 0;
UInt32 PwinsHit = 0;
UInt32 PwinsMiss = 0;
UInt32 Owins = 0;
UInt32 OwinsHit = 0;
UInt32 OwinsMiss = 0;
UInt32 failCount = 0;
UInt32 passCount = 0;
UInt32 hitCount = 0;
UInt32 missCount = 0;
for(UInt32 i = 0; i < uiNumRays; ++i)
{
bool DFfastest = ((resultsDF [i]._time <= resultsDFS[i]._time) &&
(resultsDF [i]._time <= resultsP [i]._time) &&
(resultsDF [i]._time <= resultsO [i]._time) );
bool DFSfastest = ((resultsDFS[i]._time <= resultsDF [i]._time) &&
(resultsDFS[i]._time <= resultsP [i]._time) &&
(resultsDFS[i]._time <= resultsO [i]._time) );
bool Pfastest = ((resultsP [i]._time <= resultsDF [i]._time) &&
(resultsP [i]._time <= resultsDFS[i]._time) &&
(resultsP [i]._time <= resultsO [i]._time) );
bool Ofastest = ((resultsO [i]._time <= resultsDF [i]._time) &&
(resultsO [i]._time <= resultsDFS[i]._time) &&
(resultsO [i]._time <= resultsP [i]._time) );
if((resultsDF [i]._hit == resultsDFS[i]._hit) &&
(resultsDFS[i]._hit == resultsP [i]._hit) &&
(resultsP [i]._hit == resultsO [i]._hit) )
{
if((osgabs(resultsDF [i]._dist - resultsDFS[i]._dist) >= 0.001) ||
(osgabs(resultsDFS[i]._dist - resultsP [i]._dist) >= 0.001) ||
(osgabs(resultsP [i]._dist - resultsO [i]._dist) >= 0.001) ||
(osgabs(resultsO [i]._dist - resultsDF [i]._dist) >= 0.001) )
{
++failCount;
SINFO << "FAIL: df: " << resultsDF [i]._dist
<< " dfs: " << resultsDFS[i]._dist
<< " p: " << resultsP [i]._dist
<< " o: " << resultsO [i]._dist
<< endLog;
SINFO << "FAIL: df: " << resultsDF [i]._tri
<< " dfs: " << resultsDFS[i]._tri
<< " p: " << resultsP [i]._tri
<< " o: " << resultsO [i]._tri
<< endLog;
}
else
{
++passCount;
}
if(resultsDF[i]._hit == true)
{
++hitCount;
DFwinsHit = DFfastest ? DFwinsHit + 1 : DFwinsHit;
DFSwinsHit = DFSfastest ? DFSwinsHit + 1 : DFSwinsHit;
PwinsHit = Pfastest ? PwinsHit + 1 : PwinsHit;
OwinsHit = Ofastest ? OwinsHit + 1 : OwinsHit;
}
else
{
++missCount;
DFwinsMiss = DFfastest ? DFwinsMiss + 1 : DFwinsMiss;
DFSwinsMiss = DFSfastest ? DFSwinsMiss + 1 : DFSwinsMiss;
PwinsMiss = Pfastest ? PwinsMiss + 1 : PwinsMiss;
OwinsMiss = Ofastest ? OwinsMiss + 1 : OwinsMiss;
}
DFwins = DFfastest ? DFwins + 1 : DFwins;
DFSwins = DFSfastest ? DFSwins + 1 : DFSwins;
Pwins = Pfastest ? Pwins + 1 : Pwins;
Owins = Ofastest ? Owins + 1 : Owins;
}
else
{
++failCount;
}
//SINFO << i << " \t" << (DFfastest ? "D ->" : " ") << " hit: " << resultsDF [i]._hit << " time: " << resultsDF [i]._time << endLog;
//SINFO << " \t" << (DFSfastest ? "S ->" : " ") << " hit: " << resultsDFS[i]._hit << " time: " << resultsDFS[i]._time << endLog;
//SINFO << " \t" << (Pfastest ? "P ->" : " ") << " hit: " << resultsP [i]._hit << " time: " << resultsP [i]._time << endLog;
//SINFO << " \t" << (Ofastest ? "O ->" : " ") << " hit: " << resultsO [i]._hit << " time: " << resultsO [i]._time << endLog;
}
SINFO << " df total: " << tDFTotal << (tDFTotal < tDFSTotal && tDFTotal < tPTotal && tDFTotal < tOTotal ? " *" : " ")
<< " wins: " << DFwins << " (" << (static_cast<Real32>(DFwins) / static_cast<Real32>(passCount)) * 100.0 << "%)\t"
<< " wins on hit: " << DFwinsHit << " (" << (static_cast<Real32>(DFwinsHit) / static_cast<Real32>(hitCount )) * 100.0 << "%)\t"
<< " wins on miss: " << DFwinsMiss << " (" << (static_cast<Real32>(DFwinsMiss) / static_cast<Real32>(missCount)) * 100.0 << "%)"
<< endLog;
SINFO << " dfs total: " << tDFSTotal << (tDFSTotal < tDFTotal && tDFSTotal < tPTotal && tDFSTotal < tOTotal ? " *" : " ")
<< " wins: " << DFSwins << " (" << (static_cast<Real32>(DFSwins) / static_cast<Real32>(passCount)) * 100.0 << "%)\t"
<< " wins on hit: " << DFSwinsHit << " (" << (static_cast<Real32>(DFSwinsHit) / static_cast<Real32>(hitCount )) * 100.0 << "%)\t"
<< " wins on miss: " << DFSwinsMiss << " (" << (static_cast<Real32>(DFSwinsMiss) / static_cast<Real32>(missCount)) * 100.0 << "%)"
<< endLog;
SINFO << " p total: " << tPTotal << (tPTotal < tDFTotal && tPTotal < tDFSTotal && tPTotal < tOTotal ? " *" : " ")
<< " wins: " << Pwins << " (" << (static_cast<Real32>(Pwins) / static_cast<Real32>(passCount)) * 100.0 << "%)\t"
<< " wins on hit: " << PwinsHit << " (" << (static_cast<Real32>(PwinsHit) / static_cast<Real32>(hitCount )) * 100.0 << "%)\t"
<< " wins on miss: " << PwinsMiss << " (" << (static_cast<Real32>(PwinsMiss) / static_cast<Real32>(missCount)) * 100.0 << "%)"
<< endLog;
SINFO << " o total: " << tOTotal << (tOTotal < tDFTotal && tOTotal < tDFSTotal && tOTotal < tPTotal ? " *" : " ")
<< " wins: " << Owins << " (" << (static_cast<Real32>(Owins) / static_cast<Real32>(passCount)) * 100.0 << "%)\t"
<< " wins on hit: " << OwinsHit << " (" << (static_cast<Real32>(OwinsHit) / static_cast<Real32>(hitCount )) * 100.0 << "%)\t"
<< " wins on miss: " << OwinsMiss << " (" << (static_cast<Real32>(OwinsMiss) / static_cast<Real32>(missCount)) * 100.0 << "%)"
<< endLog;
SINFO << "pass: "******" fail: " << failCount
<< " hit: " << hitCount << " miss: " << missCount << endLog;
osgLogP->setLogLevel(LOG_NOTICE);
#if 0
// create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// tell the manager what to manage
mgr->setWindow(gwin );
mgr->setRoot (pRoot);
// show the whole scene
mgr->showAll();
// GLUT main loop
glutMainLoop();
#endif
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);
//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));
//Particle System Material
PointChunkRefPtr PSPointChunk = PointChunk::create();
PSPointChunk->setSize(5.0f);
PSPointChunk->setSmooth(true);
BlendChunkRefPtr PSBlendChunk = BlendChunk::create();
PSBlendChunk->setSrcFactor(GL_SRC_ALPHA);
PSBlendChunk->setDestFactor(GL_ONE_MINUS_SRC_ALPHA);
MaterialChunkRefPtr PSMaterialChunkChunk = MaterialChunk::create();
PSMaterialChunkChunk->setAmbient(Color4f(1.0f,1.0f,1.0f,1.0f));
PSMaterialChunkChunk->setDiffuse(Color4f(0.7f,0.7f,0.7f,1.0f));
PSMaterialChunkChunk->setSpecular(Color4f(0.9f,0.9f,0.9f,1.0f));
PSMaterialChunkChunk->setColorMaterial(GL_NONE);
ChunkMaterialRefPtr PSMaterial = ChunkMaterial::create();
PSMaterial->addChunk(PSPointChunk);
PSMaterial->addChunk(PSMaterialChunkChunk);
PSMaterial->addChunk(PSBlendChunk);
//Particle System
ParticleSystemRefPtr ExampleParticleSystem = ParticleSystem::create();
ExampleParticleSystem->addParticle(Pnt3f(0,25,0),
Vec3f(0.0,0.0f,1.0f),
Color4f(1.0,1.0,1.0,1.0),
Vec3f(1.0,1.0,1.0),
0.1,
Vec3f(0.0f,0.0f,0.0f), //Velocity
Vec3f(0.0f,0.0f,0.0f)
);
ExampleParticleSystem->addParticle(Pnt3f(0,-25,0),
Vec3f(0.0,0.0f,1.0f),
Color4f(1.0,1.0,1.0,1.0),
Vec3f(1.0,1.0,1.0),
0.1,
Vec3f(0.0f,0.0f,0.0f), //Velocity
Vec3f(0.0f,0.0f,0.0f)
);
ExampleParticleSystem->attachUpdateProducer(TutorialWindow);
//Particle System Drawer (Point)
PointParticleSystemDrawerRecPtr ExamplePointParticleSystemDrawer = PointParticleSystemDrawer::create();
//Particle System Drawer (line)
LineParticleSystemDrawerRecPtr ExampleLineParticleSystemDrawer = LineParticleSystemDrawer::create();
ExampleLineParticleSystemDrawer->setLineDirectionSource(LineParticleSystemDrawer::DIRECTION_VELOCITY);
ExampleLineParticleSystemDrawer->setLineLengthSource(LineParticleSystemDrawer::LENGTH_SIZE_X);
ExampleLineParticleSystemDrawer->setLineLength(2.0f);
ExampleLineParticleSystemDrawer->setEndPointFading(Vec2f(0.0f,1.0f));
//Create a Rate Particle Generator
RateParticleGeneratorRefPtr ExampleGenerator = RateParticleGenerator::create();
//Attach the function objects to the Generator
ExampleGenerator->setPositionDistribution(createPositionDistribution());
ExampleGenerator->setLifespanDistribution(createLifespanDistribution());
ExampleGenerator->setGenerationRate(200);
UniformParticleAffectorRecPtr ExampleUniformAffector = UniformParticleAffector::create();
ExampleUniformAffector->setMagnitude(20.0); // force which the field exerts on particles (negative = towards the air field's beacon location)
NodeRefPtr UniformBeacon = Node::create();
ExampleUniformAffector->setBeacon(UniformBeacon); // set to 'emulate' from (0,0,0)
ExampleUniformAffector->setDirection(Vec3f(1.0,0.0,0.0)); // direction which field is exerted
ExampleUniformAffector->setMaxDistance(-1.0); // particles affected regardless of distance from
ExampleUniformAffector->setAttenuation(0.0); // strength of uniform field dimishes by dist^attenuation, in this case it is constant regardless of distance
ExampleUniformAffector->setParticleMass(10.0);
//Attach the Generator and Affector to the Particle System
ExampleParticleSystem->pushToGenerators(ExampleGenerator);
ExampleParticleSystem->pushToAffectors(ExampleUniformAffector);
ExampleParticleSystem->setMaxParticles(500);
//Particle System Node
ParticleSystemCoreRecPtr ParticleNodeCore = ParticleSystemCore::create();
ParticleNodeCore->setSystem(ExampleParticleSystem);
ParticleNodeCore->setDrawer(ExamplePointParticleSystemDrawer);
ParticleNodeCore->setMaterial(PSMaterial);
NodeRefPtr ParticleNode = Node::create();
ParticleNode->setCore(ParticleNodeCore);
// Make Main Scene Node and add the Torus
NodeRefPtr scene = Node::create();
scene->setCore(Group::create());
scene->addChild(ParticleNode);
TutorialWindow->connectKeyTyped(boost::bind(keyTyped, _1,
&sceneManager,
ParticleNodeCore.get(),
ExamplePointParticleSystemDrawer.get(),
ExampleLineParticleSystemDrawer.get(),
ExampleUniformAffector.get()));
sceneManager.setRoot(scene);
// Show the whole Scene
sceneManager.showAll();
sceneManager.getCamera()->setFar(1000.0);
std::cout << "Uniform Particle Affector Tutorial Controls:\n"
<< "1: Use point drawer\n"
<< "2: Use line drawer\n"
<< "W,A,S,D: Change direction of field\n"
<< "Ctrl + Q: Exit Tutorial";
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"19UniformFieldParticleAffector");
//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);
// GLUT init
int winid = setupGLUT(&argc, argv);
// the connection between GLUT and OpenSG
GLUTWindowPtr gwin= GLUTWindow::create();
gwin->setId(winid);
gwin->init();
// create the scene
// this time, create just the core of the geometry
GeometryPtr torus = makeTorusGeo( .5, 2, 8, 12 );
// create the scene
// the scene has a single group with ncopies transformations below,
// each of these carries a Node that shares the geometry
/*
The Switch NodeCore very similar to the Group, but it has the additional
capability to only show one or none of its children.
This is controlled by the choice Field, and is used below in the keys
function.
*/
// create the root Switch node
NodePtr scene = Node::create();
sw = Switch::create();
beginEditCP(sw, Switch::ChoiceFieldMask);
sw->setChoice(-2); // Note: this will be Switch::ALL in 1.2
endEditCP(sw, Switch::ChoiceFieldMask);
beginEditCP(scene, Node::CoreFieldMask | Node::ChildrenFieldMask);
scene->setCore(sw);
// create the copied geometry nodes and their transformations
for(UInt16 i = 0; i<ncopies; ++i)
{
// create the nodes for the shared Geometry core
NodePtr geonode = Node::create();
// assign the Core to the Node
beginEditCP(geonode, Node::CoreFieldMask );
{
geonode->setCore(torus);
}
endEditCP (geonode, Node::CoreFieldMask );
// add a transformation for every Geometry
NodePtr transnode = Node::create();
trans[i] = Transform::create();
beginEditCP(transnode, Node::CoreFieldMask | Node::ChildrenFieldMask);
{
transnode->setCore (trans[i]);
transnode->addChild(geonode );
}
endEditCP (transnode, Node::CoreFieldMask | Node::ChildrenFieldMask);
scene->addChild(transnode);
}
endEditCP (scene, Node::CoreFieldMask | Node::ChildrenFieldMask);
// create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// tell the manager what to manage
mgr->setWindow(gwin );
mgr->setRoot (scene);
// show the whole scene
mgr->showAll();
// GLUT main loop
glutMainLoop();
return 0;
}
