void OpenSGWidget::wheelEvent( QWheelEvent *ev )
{
mgr->mouseButtonPress(ev->delta() > 0 ? SimpleSceneManager::MouseUp
: SimpleSceneManager::MouseDown,
ev->x(), ev->y());
ev->accept();
update();
}
void OpenSGWidget::paintGL()
{
if(Thread::getCurrent() == _main_thread)
{
//printf("OpenSGWidget::paintGL from main thread!\n");
return;
}
mgr->redraw();
swapBuffers();
}
void OpenSGWidget::mouseReleaseEvent( QMouseEvent *ev )
{
UInt32 button;
switch ( ev->button() )
{
case Qt::LeftButton: button = SimpleSceneManager::MouseLeft; break;
case Qt::MidButton: button = SimpleSceneManager::MouseMiddle; break;
case Qt::RightButton: button = SimpleSceneManager::MouseRight; break;
default: return;
}
mgr->mouseButtonRelease(button, ev->x(), ev->y());
update();
}
// Initialize WIN32 & OpenSG and set up the scene
int main(int argc, char **argv)
{
preloadSharedObject("OSGTBFileIO");
// 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->connectMouseDragged(boost::bind(mouseDragged, _1, &sceneManager));
TutorialWindow->connectMouseWheelMoved(boost::bind(mouseWheelMoved, _1, &sceneManager));
TutorialWindow->connectKeyTyped(boost::bind(keyTyped, _1));
// create the scene
NodeUnrecPtr scene = makeTorus(1.0, 2.0, 16, 16);
sceneManager.setRoot (scene);
//Create the Documentation
SimpleScreenDoc TheSimpleScreenDoc(&sceneManager, TutorialWindow);
// show the whole scene
sceneManager.showAll();
//Load Sound Definitions
FCFileType::FCPtrStore NewContainers;
NewContainers = FCFileHandler::the()->read(BoostPath("Data/04SoundData.xml"));
FCFileType::FCPtrStore::iterator Itor;
for(Itor = NewContainers.begin() ; Itor != NewContainers.end() ; ++Itor)
{
//Get Sounds
if( (*Itor)->getType().isDerivedFrom(Sound::getClassType()))
{
Sounds.push_back(dynamic_pointer_cast<Sound>(*Itor));
Sounds.back()->connectSoundPlayed (boost::bind(handleSoundPlayed, _1));
Sounds.back()->connectSoundStopped (boost::bind(handleSoundStopped, _1));
Sounds.back()->connectSoundPaused (boost::bind(handleSoundPaused, _1));
Sounds.back()->connectSoundUnpaused(boost::bind(handleSoundUnpaused, _1));
Sounds.back()->connectSoundLooped (boost::bind(handleSoundLooped, _1));
}
//Get Sound Groups
if( (*Itor)->getType().isDerivedFrom(SoundGroup::getClassType()))
{
SoundGroups.push_back(dynamic_pointer_cast<SoundGroup>(*Itor));
}
}
//Initialize the Sound Manager
SoundManager::the()->attachUpdateProducer(TutorialWindow);
SoundManager::the()->setCamera(sceneManager.getCamera());
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"04 XML Sound Loading Window");
//Enter main loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
{
// Set up Window
WindowEventProducerRecPtr TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
// Create the SimpleSceneManager helper
SimpleSceneManager sceneManager;
TutorialWindow->setDisplayCallback(boost::bind(display, &sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, &sceneManager));
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
TutorialWindow->connectKeyTyped(boost::bind(keyPressed, _1));
// Make Torus Node (creates Torus in background of scene)
NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRecPtr scene = Node::create();
scene->setCore(Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRecPtr TutorialGraphics = Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
// Create a simple Font to be used with the TextField
UIFontRecPtr sampleFont = UIFont::create();
sampleFont->setSize(16);
/******************************************************
Create and edit the TextField. A TextField is
a Component which allows a single line of text
to be displayed. Text can be entered via the
keyboard, and selected with arrow keys or
the Mouse.
-setTextColor(Color4f): Determine the
Text Color.
setSelectionBoxColor(Color4f): Determine
the Color of highlighting around
selected Text.
-setSelectionTextColor(Color4f): Determine
the Color of selected Text.
-setText("TextToBeDisplayed"): Determine
initial Text within TextField.
-setFont(FontName): Determine the Font
used within TextField.
-setSelectionStart(StartCharacterNumber):
Determine the character with which
the selection will initially start.
-setSelectionEnd(EndCharacterNumber):
Determine the character which the
selection ends before.
-setAlignment(float): Determine
the alignment of the text.
The float is a percentage is from the
top of the text [0.0-1.0]. Note: be
sure to visually verify this, as due
to font size and line size this does
not always place it exactly
at the percentage point.
******************************************************/
// Create a TextField component
TextFieldRecPtr ExampleTextField = TextField::create();
ExampleTextField->setPreferredSize(Vec2f(100, 50));
ExampleTextField->setTextColor(Color4f(0.0, 0.0, 0.0, 1.0));
ExampleTextField->setSelectionBoxColor(Color4f(0.0, 0.0, 1.0, 1.0));
ExampleTextField->setSelectionTextColor(Color4f(1.0, 1.0, 1.0, 1.0));
ExampleTextField->setText("What");
ExampleTextField->setFont(sampleFont);
// The next two functions will select the "a" from above
ExampleTextField->setSelectionStart(2);
ExampleTextField->setSelectionEnd(3);
ExampleTextField->setAlignment(Vec2f(0.0,0.5));
// Create another TextField Component
TextFieldRecPtr ExampleTextField2 = TextField::create();
ExampleTextField2->setText("");
ExampleTextField2->setEmptyDescText("Write in me, please");
ExampleTextField2->setPreferredSize(Vec2f(200.0f,ExampleTextField2->getPreferredSize().y()));
// Create The Main InternalWindow
// Create Background to be used with the Main InternalWindow
ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
LayoutRecPtr MainInternalWindowLayout = FlowLayout::create();
InternalWindowRecPtr MainInternalWindow = InternalWindow::create();
MainInternalWindow->pushToChildren(ExampleTextField);
MainInternalWindow->pushToChildren(ExampleTextField2);
MainInternalWindow->setLayout(MainInternalWindowLayout);
MainInternalWindow->setBackgrounds(MainInternalWindowBackground);
MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setScalingInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setDrawTitlebar(false);
MainInternalWindow->setResizable(false);
// Create the Drawing Surface
UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRecPtr TutorialUIForeground = UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
// Tell the Manager what to manage
sceneManager.setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRecPtr TutorialViewport = sceneManager.getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
// Show the whole Scene
sceneManager.showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"16TextField");
//Enter main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
{
// Set up Window
WindowEventProducerRecPtr TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
// Create the SimpleSceneManager helper
SimpleSceneManager sceneManager;
TutorialWindow->setDisplayCallback(boost::bind(display, &sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, &sceneManager));
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
TutorialWindow->connectKeyTyped(boost::bind(keyPressed, _1));
// Make Torus Node (creates Torus in background of scene)
NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRecPtr scene = Node::create();
scene->setCore(Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRecPtr TutorialGraphics = Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
/******************************************************
Create and edit a CheckboxButton.
Note: the only function call shown
specific to CheckboxButton is setSelected.
In DefaultLookAndFeel, the options
for changing the style of the CheckBox
are shown. CheckboxButton also
inherits off Button so all features
of Button may be used.
-setSelected(bool): Determines if the
CheckboxButton is checked(true) or
not checked(false).
******************************************************/
CheckboxButtonRecPtr ExampleCheckboxButton = CheckboxButton::create();
ExampleCheckboxButton->setMinSize(Vec2f(50, 25));
ExampleCheckboxButton->setMaxSize(Vec2f(300, 100));
ExampleCheckboxButton->setPreferredSize(Vec2f(200, 50));
ExampleCheckboxButton->setEnabled(true);
ExampleCheckboxButton->setText("Checkbox Button");
ExampleCheckboxButton->setAlignment(Vec2f(0.5,0.5));
ExampleCheckboxButton->setSelected(true);
// Create The Main InternalWindow
// Create Background to be used with the Main InternalWindow
ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
LayoutRecPtr MainInternalWindowLayout = FlowLayout::create();
InternalWindowRecPtr MainInternalWindow = InternalWindow::create();
MainInternalWindow->pushToChildren(ExampleCheckboxButton);
MainInternalWindow->setLayout(MainInternalWindowLayout);
MainInternalWindow->setBackgrounds(MainInternalWindowBackground);
MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setScalingInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setDrawTitlebar(false);
MainInternalWindow->setResizable(false);
// Create the Drawing Surface
UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRecPtr TutorialUIForeground = UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
// Tell the Manager what to manage
sceneManager.setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRecPtr TutorialViewport = sceneManager.getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
// Show the whole Scene
sceneManager.showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"13CheckboxButton");
//Enter main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
{
// Set up Window
WindowEventProducerRecPtr TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
// Create the SimpleSceneManager helper
SimpleSceneManager sceneManager;
TutorialWindow->setDisplayCallback(boost::bind(display, &sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, &sceneManager));
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
TutorialWindow->connectKeyTyped(boost::bind(keyPressed, _1));
// Make Torus Node (creates Torus in background of scene)
NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRecPtr scene = Node::create();
scene->setCore(Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRecPtr TutorialGraphics = Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
/******************************************************
Create a Spinner Model. This dictates
how the Spinner functions.
-setMaximum(int): Determine the Maximum
value the Spinner can have.
-setMinimum(int): Determine the Minimum
value the Spinner can have.
-setStepSize(int): Determine the
incremental step size.
-setValue(SharedFieldRecPtr(new SFInt32(int)):
Determine initial starting value
of the Spinner.
Note: the StepSize can be changed
dynamically as done in this
Tutorial with ButtonSelectedListeners.
******************************************************/
//Int32SpinnerModelPtr TheModel(new Int32SpinnerModel());
Int32SpinnerModelPtr TheModel(new Int32SpinnerModel());
TheModel->setMaximum(100);
TheModel->setMinimum(-100);
TheModel->setStepSize(1);
TheModel->setValue(boost::any(Int32(0)));
/******************************************************
Create a Spinner and and assign it a
Model.
******************************************************/
SpinnerRecPtr ExampleSpinner = Spinner::create();
ExampleSpinner->setModel(TheModel);
/******************************************************
Create a RadioButtonPanel to allow
for certain characteristics of the
Spinner to be changed dynamically.
See 14RadioButton for more
information about RadioButtons.
******************************************************/
RadioButtonRecPtr SingleIncrementButton = RadioButton::create();
RadioButtonRecPtr DoubleIncrementButton = RadioButton::create();
SingleIncrementButton->setText("Increment by 1");
SingleIncrementButton->setPreferredSize(Vec2f(100, 50));
SingleIncrementButton->connectButtonSelected(boost::bind(handleSingleIncbuttonSelected, _1,
TheModel));
DoubleIncrementButton->setText("Increment by 2");
DoubleIncrementButton->setPreferredSize(Vec2f(100, 50));
DoubleIncrementButton->connectButtonSelected(boost::bind(handleDoubleIncbuttonSelected, _1,
TheModel));
RadioButtonGroupRecPtr SelectionRadioButtonGroup = RadioButtonGroup::create();
SelectionRadioButtonGroup->addButton(SingleIncrementButton);
SelectionRadioButtonGroup->addButton(DoubleIncrementButton);
SingleIncrementButton->setSelected(true);
// Create The Main InternalWindow
// Create Background to be used with the Main InternalWindow
ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
LayoutRecPtr MainInternalWindowLayout = FlowLayout::create();
InternalWindowRecPtr MainInternalWindow = InternalWindow::create();
MainInternalWindow->pushToChildren(SingleIncrementButton);
MainInternalWindow->pushToChildren(DoubleIncrementButton);
MainInternalWindow->pushToChildren(ExampleSpinner);
MainInternalWindow->setLayout(MainInternalWindowLayout);
MainInternalWindow->setBackgrounds(MainInternalWindowBackground);
MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setScalingInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setDrawTitlebar(false);
MainInternalWindow->setResizable(false);
// Create the Drawing Surface
UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRecPtr TutorialUIForeground = UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
// Tell the Manager what to manage
sceneManager.setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRecPtr TutorialViewport = sceneManager.getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
// Show the whole Scene
sceneManager.showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"29Spinner");
//Enter main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
{
// Set up Window
WindowEventProducerRecPtr TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
// Create the SimpleSceneManager helper
SimpleSceneManager sceneManager;
TutorialWindow->setDisplayCallback(boost::bind(display, &sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, &sceneManager));
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
TutorialWindow->connectKeyTyped(boost::bind(keyPressed, _1));
// Make Torus Node (creates Torus in background of scene)
NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRecPtr scene = Node::create();
scene->setCore(Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRecPtr TutorialGraphics = Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
// Create a simple Font to be used with the PasswordField
UIFontRecPtr ExampleFont = UIFont::create();
ExampleFont->setSize(16);
/******************************************************
Create and edit a PasswordField.
A PasswordField is a TextField
which allows for text to be
entered secretly.
-setEchoCar("char"): Determine
which character replaces text in the
PasswordField.
See 16TextField for more information.
******************************************************/
TextFieldRecPtr ExampleTextField = TextField::create();
ExampleTextField->setText("");
ExampleTextField->setEmptyDescText("username");
ExampleTextField->setPreferredSize(Vec2f(130.0f,ExampleTextField->getPreferredSize().y()));
PasswordFieldRecPtr ExamplePasswordField = PasswordField::create();
ExamplePasswordField->setPreferredSize(Vec2f(130, ExamplePasswordField->getPreferredSize().y()));
ExamplePasswordField->setTextColor(Color4f(0.0, 0.0, 0.0, 1.0));
ExamplePasswordField->setSelectionBoxColor(Color4f(0.0, 0.0, 1.0, 1.0));
ExamplePasswordField->setSelectionTextColor(Color4f(1.0, 1.0, 1.0, 1.0));
//ExamplePasswordField->setText("Text");
// "Text" will be replaced by "####" in the PasswordField
ExamplePasswordField->setEchoChar("#");
ExamplePasswordField->setEditable(true);
ExamplePasswordField->setFont(ExampleFont);
ExamplePasswordField->setSelectionStart(2);
ExamplePasswordField->setSelectionEnd(3);
ExamplePasswordField->setAlignment(Vec2f(0.0,0.5));
ExamplePasswordField->setEmptyDescText("password");
// Create The Main InternalWindow
// Create Background to be used with the Main InternalWindow
ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
FlowLayoutRecPtr MainInternalWindowLayout = FlowLayout::create();
MainInternalWindowLayout->setOrientation(FlowLayout::VERTICAL_ORIENTATION);
InternalWindowRecPtr MainInternalWindow = InternalWindow::create();
MainInternalWindow->pushToChildren(ExampleTextField);
MainInternalWindow->pushToChildren(ExamplePasswordField);
MainInternalWindow->setLayout(MainInternalWindowLayout);
MainInternalWindow->setBackgrounds(MainInternalWindowBackground);
MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setScalingInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setDrawTitlebar(false);
MainInternalWindow->setResizable(false);
// Create the Drawing Surface
UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRecPtr TutorialUIForeground = UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
// Tell the Manager what to manage
sceneManager.setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRecPtr TutorialViewport = sceneManager.getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
//Create the Documentation Foreground and add it to the viewport
SimpleScreenDoc TheSimpleScreenDoc(&sceneManager, TutorialWindow);
// Show the whole Scene
sceneManager.showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"24PasswordField");
//Enter main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
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->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));
// Creating the Particle System Material
// Here, the image is loaded. The entire image sequence is conatined in one image,
// which reduces texture memory overhead and runs faster.
TextureObjChunkRefPtr QuadTextureChunk = TextureObjChunk::create();
ImageRefPtr LoadedImage = ImageFileHandler::the()->read("Data/SpriteExplode.png");
QuadTextureChunk->setImage(LoadedImage);
TextureEnvChunkRefPtr QuadTextureEnvChunk = TextureEnvChunk::create();
QuadTextureEnvChunk->setEnvMode(GL_MODULATE);
BlendChunkRefPtr PSBlendChunk = BlendChunk::create();
PSBlendChunk->setSrcFactor(GL_SRC_ALPHA);
PSBlendChunk->setDestFactor(GL_ONE_MINUS_SRC_ALPHA);
MaterialChunkRefPtr PSMaterialChunk = MaterialChunk::create();
PSMaterialChunk->setAmbient(Color4f(0.3f,0.0f,0.0f,1.0f));
PSMaterialChunk->setDiffuse(Color4f(0.7f,0.0f,0.0f,1.0f));
PSMaterialChunk->setSpecular(Color4f(0.9f,0.0f,0.0f,1.0f));
PSMaterialChunk->setColorMaterial(GL_AMBIENT_AND_DIFFUSE);
ChunkMaterialRefPtr PSMaterial = ChunkMaterial::create();
PSMaterial->addChunk(QuadTextureChunk);
PSMaterial->addChunk(QuadTextureEnvChunk);
PSMaterial->addChunk(PSMaterialChunk);
PSMaterial->addChunk(PSBlendChunk);
//Particle System
ParticleSystemRecPtr ExampleParticleSystem = ParticleSystem::create();
ExampleParticleSystem->attachUpdateProducer(TutorialWindow);
//Age Particle Function. Controls which image is shown when, based on the age of a particle.
AgeParticleFunctionRecPtr AgeFunc = AgeParticleFunction::create();
AgeFunc->setSequenceTime(0.1f); // image changes every 0.1 seconds.
AgeFunc->setSequenceOrder(AgeParticleFunction::CUSTOM); // using the custom sequence below.
/*
Here, a custom sequence for the image ordering is assembled. The image sequence will be shown in
the order specified here. Once the end of the sequence is reached, the sequence repeats.
*/
AgeFunc->editMFCustomSequence()->push_back(0);
AgeFunc->editMFCustomSequence()->push_back(1);
AgeFunc->editMFCustomSequence()->push_back(2);
AgeFunc->editMFCustomSequence()->push_back(3);
AgeFunc->editMFCustomSequence()->push_back(4);
AgeFunc->editMFCustomSequence()->push_back(5);
AgeFunc->editMFCustomSequence()->push_back(4);
AgeFunc->editMFCustomSequence()->push_back(3);
AgeFunc->editMFCustomSequence()->push_back(2);
AgeFunc->editMFCustomSequence()->push_back(1);
//Particle System Drawer -
QuadSequenceParticleSystemDrawerRecPtr ExampleParticleSystemDrawer = QuadSequenceParticleSystemDrawer::create();
// image dimensions (in pixels) are required if there is a border on the images.
ExampleParticleSystemDrawer->setImageDimensions(Vec2us(780,520));
// The "dimensions" of the sequence contained in the image. For this image,
// there are 3 images in the "x" direction, and two in the "y" direction, for a
// total of 6.
ExampleParticleSystemDrawer->setSequenceDimensions(Vec2b(3,2));
// width of the border on each side of the image, in pixels.
ExampleParticleSystemDrawer->setBorderOffsets(Vec2b(0,0));
// this is the age function we just created above.
ExampleParticleSystemDrawer->setSequenceFunction(AgeFunc);
RateParticleGeneratorRecPtr ExampleParticleGenerator = RateParticleGenerator::create();
//Attach the function objects to the Generator
ExampleParticleGenerator->setPositionDistribution(createPositionDistribution());
ExampleParticleGenerator->setLifespanDistribution(createLifespanDistribution());
ExampleParticleGenerator->setVelocityDistribution(createVelocityDistribution());
ExampleParticleGenerator->setAccelerationDistribution(createAccelerationDistribution());
ExampleParticleGenerator->setSizeDistribution(createSizeDistribution());
ExampleParticleGenerator->setGenerationRate(40.0f);
//Particle System Node
ParticleSystemCoreRefPtr ParticleNodeCore = ParticleSystemCore::create();
ParticleNodeCore->setSystem(ExampleParticleSystem);
ParticleNodeCore->setDrawer(ExampleParticleSystemDrawer);
ParticleNodeCore->setMaterial(PSMaterial);
ParticleNodeCore->setSortingMode(ParticleSystemCore::BACK_TO_FRONT);
NodeRefPtr ParticleNode = Node::create();
ParticleNode->setCore(ParticleNodeCore);
ExampleParticleSystem->addParticle(Pnt3f(10.0,0.0,0.0),
Vec3f(0.0,1.0,0.0),
Color4f(1.0,1.0,1.0,1.0),
Vec3f(1.0,1.0,1.0),
0.01,
Vec3f(0.0,0.0,0.0),
Vec3f(0.0,0.0,0.0));
ExampleParticleSystem->addParticle(Pnt3f(-10.0,0.0,0.0),
Vec3f(0.0,1.0,0.0),
Color4f(1.0,1.0,1.0,1.0),
Vec3f(1.0,1.0,1.0),
0.01,
Vec3f(0.0,0.0,0.0),
Vec3f(0.0,0.0,0.0));
ExampleParticleSystem->pushToGenerators(ExampleParticleGenerator);
// Make Main Scene Node and add the Torus
NodeRefPtr scene = makeCoredNode<Group>();
scene->addChild(ParticleNode);
TutorialWindow->connectKeyTyped(boost::bind(keyTyped, _1,
&sceneManager,
AgeFunc.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,
"05a - QuadSequenceParticleDrawer");
//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
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;
}
// 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;
}
void OpenSGWidget::paintGL()
{
mgr->redraw();
swapBuffers();
}
void OpenSGWidget::resizeGL( int width, int height )
{
mgr->resize(width,height);
}
// Initialize WIN32 & OpenSG and set up the scene
int main(int argc, char **argv)
{
std::cout << "\n\nKEY COMMANDS:" << std::endl
<< "space Play/Pause the playing sounds" << std::endl
<< "1 Play Pop Sound" << std::endl
<< "2 Play Click Sound" << std::endl
<< "CTRL-Q Exit\n\n" << std::endl;
// 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));
// create the scene
NodeUnrecPtr scene = makeTorus(1.0, 2.0, 16, 16);
//Initialize the Sound Manager
SoundManager::the()->attachUpdateProducer(TutorialWindow);
SoundManager::the()->setCamera(sceneManager.getCamera());
//Create Pop Sound
SoundRecPtr ZapSound = SoundManager::the()->createSound();
ZapSound->setFile(BoostPath("./Data/zap.wav"));
ZapSound->setVolume(1.0);
ZapSound->setStreaming(false);
ZapSound->setLooping(1);
//Attach Sound Events
ZapSound->connectSoundPlayed (boost::bind(handleSoundPlayed, _1));
ZapSound->connectSoundStopped (boost::bind(handleSoundStopped, _1));
ZapSound->connectSoundPaused (boost::bind(handleSoundPaused, _1));
ZapSound->connectSoundUnpaused(boost::bind(handleSoundUnpaused, _1));
ZapSound->connectSoundLooped (boost::bind(handleSoundLooped, _1));
//Create Click Sound
SoundRecPtr ClickSound = SoundManager::the()->createSound();
ClickSound->setFile(BoostPath("./Data/click.wav"));
ClickSound->setVolume(1.0);
ClickSound->setStreaming(false);
ClickSound->setLooping(0);
//Attach Sound Events
ClickSound->connectSoundPlayed (boost::bind(handleSoundPlayed, _1));
ClickSound->connectSoundStopped (boost::bind(handleSoundStopped, _1));
ClickSound->connectSoundPaused (boost::bind(handleSoundPaused, _1));
ClickSound->connectSoundUnpaused(boost::bind(handleSoundUnpaused, _1));
ClickSound->connectSoundLooped (boost::bind(handleSoundLooped, _1));
TutorialWindow->connectKeyTyped(boost::bind(&KeyTypedHandler::keyTyped,
_1,
ZapSound.get(),
ClickSound.get()));
// 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,
"01 DefaultSound Window");
//Enter main loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
{
TheLuaManager->init();
// Set up Window
WindowEventProducerRecPtr TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
// Create the SimpleSceneManager helper
SimpleSceneManager sceneManager;
TutorialWindow->setDisplayCallback(boost::bind(display, &sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, &sceneManager));
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
//Setup the Lua Manager
BoostPath ModulePath("./Data/");
std::string PackagePath = std::string("?;")
+ (ModulePath / "?.lua" ).file_string() + ";"
+ (ModulePath / "?" / "init.lua").file_string();
TheLuaManager->setPackagePath(PackagePath);
// Make Torus Node (creates Torus in background of scene)
GeometryRefPtr TorusGeometry = makeTorusGeo(.5, 2, 16, 16);
setName(TorusGeometry,"Torus Geometry");
//calcVertexTangents(TorusGeometry,0,Geometry::TexCoords7FieldId, Geometry::TexCoords6FieldId);
NodeRefPtr TorusGeometryNode = Node::create();
setName(TorusGeometryNode,"Torus Geometry Node");
TorusGeometryNode->setCore(TorusGeometry);
//Torus Transformation Node
TransformRefPtr TheTorusNodeTransform = Transform::create();
NodeRefPtr TheTorusTransfromNode = Node::create();
TheTorusTransfromNode->setCore(TheTorusNodeTransform);
TheTorusTransfromNode->addChild(TorusGeometryNode);
setName(TheTorusTransfromNode,"Torus Transform Node");
// Make Main Scene Node and add the Torus
NodeRefPtr scene = Node::create();
scene->setCore(Group::create());
scene->addChild(TheTorusTransfromNode);
setName(scene,"Scene Node");
//Light Beacon Node
TransformRefPtr TheLightBeaconNodeTransform = Transform::create();
NodeRefPtr TheLightBeaconNode = Node::create();
TheLightBeaconNode->setCore(TheLightBeaconNodeTransform);
setName(TheLightBeaconNode,"Light Beacon Node");
//Light Node
DirectionalLightRefPtr TheLightCore = DirectionalLight::create();
TheLightCore->setDirection(Vec3f(1.0,0.0,0.0));
TheLightCore->setAmbient(Color4f(1.0,1.0,1.0,1.0));
TheLightCore->setDiffuse(Color4f(1.0,1.0,1.0,1.0));
TheLightCore->setSpecular(Color4f(1.0,1.0,1.0,1.0));
TheLightCore->setBeacon(TheLightBeaconNode);
NodeRefPtr TheLightNode = Node::create();
TheLightNode->setCore(TheLightCore);
TheLightNode->addChild(scene);
setName(TheLightNode,"Light Node");
NodeRefPtr RootNode = Node::create();
RootNode->setCore(Group::create());
RootNode->addChild(TheLightNode);
RootNode->addChild(TheLightBeaconNode);
setName(RootNode,"Root Node");
// Create the Graphics
GraphicsRefPtr TutorialGraphics = Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
//Create the Main interface
LuaDebuggerInterface TheLuaDebuggerInterface;
// Create The Main InternalWindow
// Create Background to be used with the Main InternalWindow
ColorLayerRefPtr MainInternalWindowBackground = ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
BorderLayoutRefPtr MainInternalWindowLayout = BorderLayout::create();
//Split Panel
BorderLayoutConstraintsRefPtr SplitPanelConstraints = BorderLayoutConstraints::create();
SplitPanelConstraints->setRegion(BorderLayoutConstraints::BORDER_CENTER);
TheLuaDebuggerInterface.getMainSplitPanel()->setConstraints(SplitPanelConstraints);
BorderLayoutConstraintsRefPtr ButtonPanelConstraints = BorderLayoutConstraints::create();
ButtonPanelConstraints->setRegion(BorderLayoutConstraints::BORDER_NORTH);
TheLuaDebuggerInterface.getButtonPanel()->setConstraints(ButtonPanelConstraints);
BorderLayoutConstraintsRefPtr CodeAreaInfoPanelConstraints = BorderLayoutConstraints::create();
CodeAreaInfoPanelConstraints->setRegion(BorderLayoutConstraints::BORDER_SOUTH);
TheLuaDebuggerInterface.getCodeAreaInfoPanel()->setConstraints(CodeAreaInfoPanelConstraints);
InternalWindowRefPtr MainInternalWindow = InternalWindow::create();
MainInternalWindow->pushToChildren(TheLuaDebuggerInterface.getButtonPanel());
MainInternalWindow->pushToChildren(TheLuaDebuggerInterface.getMainSplitPanel());
MainInternalWindow->pushToChildren(TheLuaDebuggerInterface.getCodeAreaInfoPanel());
MainInternalWindow->setLayout(MainInternalWindowLayout);
MainInternalWindow->setBackgrounds(MainInternalWindowBackground);
MainInternalWindow->setTitle("Lua Debugger");
setName(MainInternalWindow,"Internal Window");
// Create the Drawing Surface
UIDrawingSurfaceRefPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRefPtr TutorialUIForeground = UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
//Scene Background
GradientBackgroundRefPtr SceneBackground = GradientBackground::create();
SceneBackground->addLine(Color3f(0.0,0.0,0.0),0.0);
setName(SceneBackground,"Scene Background");
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
sceneManager.setRoot(RootNode);
//sceneManager.setHeadlight(false);
// Add the UI Foreground Object to the Scene
ViewportRefPtr TutorialViewport = sceneManager.getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
TutorialViewport->setBackground(SceneBackground);
TutorialWindow->connectKeyTyped(boost::bind(keyTyped,
_1,
&TheLuaDebuggerInterface));
// Show the whole Scene
sceneManager.showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"03LuaDebugger");
MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setPreferredSize(WinSize * 0.85);
//Enter main Loop
TutorialWindow->mainLoop();
TheLuaManager->uninit();
}
osgExit();
return 0;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
{
// Set up Window
WindowEventProducerRecPtr TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
// Create the SimpleSceneManager helper
SimpleSceneManager sceneManager;
TutorialWindow->setDisplayCallback(boost::bind(display, &sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, &sceneManager));
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
TutorialWindow->connectKeyTyped(boost::bind(keyPressed, _1));
// Make Torus Node (creates Torus in background of scene)
NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRecPtr scene = Node::create();
scene->setCore(Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRecPtr TutorialGraphics = Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
//Create the nessicary parts for a viewport
Matrix TransformMatrix;
TransformMatrix.setTranslate(0.0f,0.0f, 0.0f);
TransformRecPtr CameraBeaconTransform = Transform::create();
CameraBeaconTransform->setMatrix(TransformMatrix);
NodeRecPtr CameraBeaconNode = Node::create();
CameraBeaconNode->setCore(CameraBeaconTransform);
// Make Torus Node (creates Torus in background of scene)
NodeRecPtr GeometryNode = makeTorus(.5, 2, 32, 32);
//Make a light Node
NodeRecPtr LightBeaconNode = makeCoredNode<Transform>();
DirectionalLightRecPtr SceneLight = DirectionalLight::create();
SceneLight->setAmbient(Color4f(0.3f,0.3f,0.3f,1.0f));
SceneLight->setDiffuse(Color4f(0.8f,0.8f,0.8f,1.0f));
SceneLight->setSpecular(Color4f(1.0f,1.0f,1.0f,1.0f));
SceneLight->setOn(true);
SceneLight->setBeacon(LightBeaconNode);
NodeRecPtr LightNode = makeNodeFor(SceneLight);
LightNode->addChild(GeometryNode);
// Make Main Scene Node and add the Torus
NodeRecPtr DefaultRootNode = Node::create();
DefaultRootNode->setCore(Group::create());
DefaultRootNode->addChild(LightNode);
DefaultRootNode->addChild(LightBeaconNode);
DefaultRootNode->addChild(CameraBeaconNode);
//Camera
PerspectiveCameraRecPtr DefaultCamera = PerspectiveCamera::create();
DefaultCamera->setBeacon(CameraBeaconNode);
DefaultCamera->setFov (osgDegree2Rad(60.f));
DefaultCamera->setNear (0.1f);
DefaultCamera->setFar (100.f);
//Background
GradientBackgroundRecPtr DefaultBackground = GradientBackground::create();
DefaultBackground->addLine(Color3f(0.0f,0.0f,0.0f), 0.0f);
DefaultBackground->addLine(Color3f(0.0f,0.0f,1.0f), 1.0f);
//Viewport
ViewportRecPtr DefaultViewport = Viewport::create();
DefaultViewport->setCamera (DefaultCamera);
DefaultViewport->setRoot (DefaultRootNode);
DefaultViewport->setSize (0.0f,0.0f, 1.0f,1.0f);
DefaultViewport->setBackground (DefaultBackground);
//GL Viewport Component
LineBorderRecPtr TheGLViewportBorder = LineBorder::create();
TheGLViewportBorder->setColor(Color4f(1.0,0.0,0.0,1.0));
TheGLViewportBorder->setWidth(3.0);
GLViewportRecPtr TheGLViewport = GLViewport::create();
TheGLViewport->setPort(DefaultViewport);
TheGLViewport->setPreferredSize(Vec2f(400.0f,400.0f));
TheGLViewport->setBorders(TheGLViewportBorder);
TheGLViewport->lookAt(Pnt3f(0.0f,0.0f,10.0f), //From
Pnt3f(0.0f,0.0f,0.0f), //At
Vec3f(0.0f,1.0f,0.0f)); //Up
ButtonRecPtr ExampleButton = Button::create();
ExampleButton->setText("Example");
// Create The Main InternalWindow
// Create Background to be used with the Main InternalWindow
ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
InternalWindowRecPtr MainInternalWindow = InternalWindow::create();
LayoutRecPtr MainInternalWindowLayout = FlowLayout::create();
MainInternalWindow->pushToChildren(TheGLViewport);
MainInternalWindow->pushToChildren(ExampleButton);
MainInternalWindow->setLayout(MainInternalWindowLayout);
MainInternalWindow->setBackgrounds(MainInternalWindowBackground);
MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setScalingInDrawingSurface(Vec2f(0.95f,0.95f));
MainInternalWindow->setDrawTitlebar(false);
MainInternalWindow->setResizable(false);
// Create the Drawing Surface
UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRecPtr TutorialUIForeground = UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
// Tell the Manager what to manage
sceneManager.setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRecPtr TutorialViewport = sceneManager.getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
//Create the Documentation Foreground and add it to the viewport
SimpleScreenDoc TheSimpleScreenDoc(&sceneManager, TutorialWindow);
// Show the whole Scene
sceneManager.showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"41GLViewportComponent");
//Enter main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
{
// Set up Window
WindowEventProducerRecPtr TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
// Create the SimpleSceneManager helper
SimpleSceneManager sceneManager;
TutorialWindow->setDisplayCallback(boost::bind(display, &sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, &sceneManager));
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
TutorialWindow->connectKeyTyped(boost::bind(keyPressed, _1));
// Make Torus Node (creates Torus in background of scene)
NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRecPtr scene = Node::create();
scene->setCore(Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRecPtr TutorialGraphics = Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
/******************************************************
Create an Button Component and
a simple Font.
See 17Label_Font for more
information about Fonts.
******************************************************/
ButtonRecPtr ExampleButton = Button::create();
UIFontRecPtr ExampleFont = UIFont::create();
ExampleFont->setSize(16);
ExampleButton->setMinSize(Vec2f(50, 25));
ExampleButton->setMaxSize(Vec2f(200, 100));
ExampleButton->setPreferredSize(Vec2f(100, 50));
ExampleButton->setToolTipText("Button 1 ToolTip");
ExampleButton->setText("Button 1");
ExampleButton->setFont(ExampleFont);
ExampleButton->setTextColor(Color4f(1.0, 0.0, 0.0, 1.0));
ExampleButton->setRolloverTextColor(Color4f(1.0, 0.0, 1.0, 1.0));
ExampleButton->setActiveTextColor(Color4f(1.0, 0.0, 0.0, 1.0));
ExampleButton->setAlignment(Vec2f(1.0,0.0));
/******************************************************
Create a ToggleButton and determine its
characteristics. ToggleButton inherits
off of Button, so all characteristsics
used above can be used with ToggleButtons
as well.
The only difference is that when pressed,
ToggleButton remains pressed until pressed
again.
-setSelected(bool): Determine whether the
ToggleButton is Selected (true) or
deselected (false).
******************************************************/
ToggleButtonRecPtr ExampleToggleButton = ToggleButton::create();
ExampleToggleButton->setSelected(false);
ExampleToggleButton->setText("ToggleMe");
ExampleToggleButton->setToolTipText("Toggle Button ToolTip");
// Create Background to be used with the MainInternalWindow
ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
// Create The Internal Window
InternalWindowRecPtr MainInternalWindow = InternalWindow::create();
LayoutRecPtr MainInternalWindowLayout = FlowLayout::create();
// Assign the Button to the MainInternalWindow so it will be displayed
// when the view is rendered.
MainInternalWindow->pushToChildren(ExampleButton);
MainInternalWindow->setLayout(MainInternalWindowLayout);
MainInternalWindow->setBackgrounds(MainInternalWindowBackground);
MainInternalWindow->setPosition(Pnt2f(50,50));
MainInternalWindow->setPreferredSize(Vec2f(300,300));
MainInternalWindow->setTitle(std::string("Internal Window 1"));
// Create The Internal Window
InternalWindowRecPtr MainInternalWindow2 = InternalWindow::create();
LayoutRecPtr MainInternalWindowLayout2 = FlowLayout::create();
// Assign the Button to the MainInternalWindow so it will be displayed
// when the view is rendered.
MainInternalWindow2->pushToChildren(ExampleToggleButton);
MainInternalWindow2->setLayout(MainInternalWindowLayout2);
MainInternalWindow2->setBackgrounds(MainInternalWindowBackground);
MainInternalWindow2->setPosition(Pnt2f(150,150));
MainInternalWindow2->setPreferredSize(Vec2f(300,300));
MainInternalWindow2->setTitle(std::string("Allways on top window"));
MainInternalWindow2->setIconable(false);
MainInternalWindow2->setAllwaysOnTop(true);
// Create the Drawing Surface
UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow2);
// Create the UI Foreground Object
UIForegroundRecPtr TutorialUIForeground = UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
// Tell the Manager what to manage
sceneManager.setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRecPtr TutorialViewport = sceneManager.getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
// Show the whole Scene
sceneManager.showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"37InternalWindow");
//Enter main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
// Initialize 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)
{
// OSG init
osgInit(argc,argv);
{
// Set up Window
WindowEventProducerRecPtr TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
// Create the SimpleSceneManager helper
SimpleSceneManager sceneManager;
TutorialWindow->setDisplayCallback(boost::bind(display, &sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, &sceneManager));
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
TutorialWindow->connectKeyTyped(boost::bind(keyPressed, _1));
// Make Torus Node (creates Torus in background of scene)
NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRecPtr scene = Node::create();
scene->setCore(Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRecPtr TutorialGraphics = Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
/******************************************************
Create BorderLayout and some
BorderLayoutConstraints to be used
to set up CardLayout.
******************************************************/
BorderLayoutRecPtr MainInternalWindowLayout = BorderLayout::create();
BorderLayoutConstraintsRecPtr ExampleButton1Constraints = BorderLayoutConstraints::create();
BorderLayoutConstraintsRecPtr ExampleButton2Constraints = BorderLayoutConstraints::create();
BorderLayoutConstraintsRecPtr ExampleButton7Constraints = BorderLayoutConstraints::create();
BorderLayoutConstraintsRecPtr ExampleButton8Constraints = BorderLayoutConstraints::create();
BorderLayoutConstraintsRecPtr ExampleCardPanelConstraints = BorderLayoutConstraints::create();
ExampleButton1Constraints->setRegion(BorderLayoutConstraints::BORDER_EAST);
ExampleButton2Constraints->setRegion(BorderLayoutConstraints::BORDER_WEST);
ExampleButton7Constraints->setRegion(BorderLayoutConstraints::BORDER_NORTH);
ExampleButton8Constraints->setRegion(BorderLayoutConstraints::BORDER_SOUTH);
ExampleCardPanelConstraints->setRegion(BorderLayoutConstraints::BORDER_CENTER);
/******************************************************
Create CardLayout. CardLayout shows
a single Component at a time, meaning
it is not exactly practical to use it
alone for a Layout. This tutorial uses
the BorderLayout to include a Panel in
the Center Region, and within that Panel
using a CardLayout. A single card is
displayed at one time within a
ComponentContainer using CardLayout.
CardLayout has four functions:
next, previous, first, and last.
->next(CardContainerName): Causes
CardLayout to display the next card.
->previous(CardContainerName): Causes
CardLayout to display the
previous card.
->first(CardContainerName): Causes
CardLayout to display the
first card.
->last(CardContainerName): Causes
CardLayout to display the
last card.
These are most useful when combined with
Action, as shown at the top of
this Tutorial, to assign actions to the
Buttons or Components to allow the user
to cycle through the Card Layout and
view different ExampleCards.
Note that CardContainerName is the name
of the ComponentContainer which is using the
CardLayout, while the begin/endEditCP
is performed on the CardLayout itself.
******************************************************/
CardLayoutRecPtr ExampleCardLayout = CardLayout::create();
PanelRecPtr ExampleCardPanel = Panel::create();
/******************************************************
Create Button Components to be used with
CardLayout to allow for interactivity.
******************************************************/
ButtonRecPtr ExampleButton1 = Button::create();
ButtonRecPtr ExampleButton2 = Button::create();
ButtonRecPtr ExampleButton3 = Button::create();
ButtonRecPtr ExampleButton4 = Button::create();
ButtonRecPtr ExampleButton5 = Button::create();
ButtonRecPtr ExampleButton6 = Button::create();
ButtonRecPtr ExampleButton7 = Button::create();
ButtonRecPtr ExampleButton8 = Button::create();
ExampleButton1->setText("Next Card");
ExampleButton1->setConstraints(ExampleButton1Constraints);
// Add Action
ExampleButton1->connectActionPerformed(boost::bind(handleNextCardAction, _1,
ExampleCardLayout.get(),
ExampleCardPanel.get()));
ExampleButton2->setText("Previous Card");
ExampleButton2->setConstraints(ExampleButton2Constraints);
// Add Action
ExampleButton2->connectActionPerformed(boost::bind(handleBackCardAction, _1,
ExampleCardLayout.get(),
ExampleCardPanel.get()));
ExampleButton3->setText("This");
ExampleButton4->setText("is");
ExampleButton5->setText("Card");
ExampleButton6->setText("Layout");
ExampleButton7->setText("First Card");
ExampleButton7->setConstraints(ExampleButton7Constraints);
// Add Action
ExampleButton7->connectActionPerformed(boost::bind(handleFirstCardAction, _1,
ExampleCardLayout.get(),
ExampleCardPanel.get()));
ExampleButton8->setText("Last Card");
ExampleButton8->setConstraints(ExampleButton8Constraints);
// Add Action
ExampleButton8->connectActionPerformed(boost::bind(handleLastCardAction, _1,
ExampleCardLayout.get(),
ExampleCardPanel.get()));
ExampleCardPanel->setLayout(ExampleCardLayout);
ExampleCardPanel->pushToChildren(ExampleButton3);
ExampleCardPanel->pushToChildren(ExampleButton4);
ExampleCardPanel->pushToChildren(ExampleButton5);
ExampleCardPanel->pushToChildren(ExampleButton6);
ExampleCardPanel->setConstraints(ExampleCardPanelConstraints);
// Create The Main InternalWindow
// Create Background to be used with the Main InternalWindow
ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
InternalWindowRecPtr MainInternalWindow = InternalWindow::create();
MainInternalWindow->pushToChildren(ExampleButton1);
MainInternalWindow->pushToChildren(ExampleButton2);
MainInternalWindow->pushToChildren(ExampleButton7);
MainInternalWindow->pushToChildren(ExampleButton8);
MainInternalWindow->pushToChildren(ExampleCardPanel);
MainInternalWindow->setLayout(MainInternalWindowLayout);
MainInternalWindow->setBackgrounds(MainInternalWindowBackground);
MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setScalingInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setDrawTitlebar(false);
MainInternalWindow->setResizable(false);
// Create the Drawing Surface
UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRecPtr TutorialUIForeground = UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
// Tell the Manager what to manage
sceneManager.setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRecPtr TutorialViewport = sceneManager.getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
//Create the Documentation Foreground and add it to the viewport
SimpleScreenDoc TheSimpleScreenDoc(&sceneManager, TutorialWindow);
// Show the whole Scene
sceneManager.showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"11CardLayout");
//Enter main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
int main(int argc, char **argv)
{
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;
}
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->connectKeyTyped(boost::bind(keyTyped, _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(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(PSPointChunk);
PSMaterial->addChunk(PSMaterialChunkChunk);
PSMaterial->addChunk(PSBlendChunk);
Distribution3DRefPtr PositionDistribution = createPositionDistribution();
Pnt3f PositionReturnValue;
//Particle System
ParticleSystemRefPtr 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,
Vec3f(0.0f,0.0f,1.0f),
Color4f(1.0,0.0,0.0,1.0),
Vec3f(1.0,1.0,1.0),
-1,
Vec3f(0.0f,0.0f,0.0f), //Velocity
Vec3f(0.0f,0.0f,0.0f) //acceleration
);
}
ExampleParticleSystem->attachUpdateProducer(TutorialWindow);
//Particle System Drawer
PointParticleSystemDrawerRefPtr ExampleParticleSystemDrawer = PointParticleSystemDrawer::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 and add the Torus
NodeRefPtr scene = Node::create();
scene->setCore(Group::create());
scene->addChild(ParticleNode);
sceneManager.setRoot(scene);
// Show the whole Scene
sceneManager.showAll();
//Create an DistanceKill
DistanceKillParticleAffectorRefPtr ExampleDistanceKillParticleAffector = DistanceKillParticleAffector::create();
ExampleDistanceKillParticleAffector->setKillDistance(1000.0f);
ExampleDistanceKillParticleAffector->setParticleSystemNode(ParticleNode);
ExampleDistanceKillParticleAffector->setDistanceFromSource(DistanceKillParticleAffector::DISTANCE_FROM_CAMERA);
ExampleDistanceKillParticleAffector->setDistanceFromCamera(sceneManager.getCamera());
ExampleParticleSystem->pushToAffectors(ExampleDistanceKillParticleAffector);
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"09DistanceKillParticleAffector");
//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;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
{
// Set up Window
WindowEventProducerRecPtr TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
// Create the SimpleSceneManager helper
SimpleSceneManager sceneManager;
TutorialWindow->setDisplayCallback(boost::bind(display, &sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, &sceneManager));
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
TutorialWindow->connectKeyTyped(boost::bind(keyPressed, _1));
// Make Torus Node (creates Torus in background of scene)
NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRecPtr scene = Node::create();
scene->setCore(Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRecPtr TutorialGraphics = Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
/******************************************************
Creates some Button components
and edit their Text.
******************************************************/
ButtonRecPtr ExampleButton1 = Button::create();
ButtonRecPtr ExampleButton2 = Button::create();
ButtonRecPtr ExampleButton3 = Button::create();
ButtonRecPtr ExampleButton4 = Button::create();
ButtonRecPtr ExampleButton5 = Button::create();
ButtonRecPtr ExampleButton6 = Button::create();
ExampleButton1->setText("This");
ExampleButton2->setText("is a");
ExampleButton3->setText("sample");
ExampleButton4->setText("two");
ExampleButton5->setText("ExamplePanel");
ExampleButton6->setText("layout");
/******************************************************
Create some Flow and BoxLayouts to be
used with the Main Frame and two
Panels.
******************************************************/
FlowLayoutRecPtr MainInternalWindowLayout = FlowLayout::create();
FlowLayoutRecPtr ExamplePanel1Layout = FlowLayout::create();
FlowLayoutRecPtr ExamplePanel2Layout = FlowLayout::create();
ExamplePanel1Layout->setOrientation(FlowLayout::VERTICAL_ORIENTATION);
/******************************************************
Create two Backgrounds to be used with
Panels and MainInternalWindow.
******************************************************/
ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create();
ColorLayerRecPtr ExamplePanelBackground = ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
ExamplePanelBackground->setColor(Color4f(0.0,0.0,0.0,1.0));
/******************************************************
Create a Border to be used with
the two Panels.
******************************************************/
LineBorderRecPtr ExamplePanelBorder = LineBorder::create();
ExamplePanelBorder->setColor(Color4f(0.9, 0.9, 0.9, 1.0));
ExamplePanelBorder->setWidth(3);
/******************************************************
Create MainInternalWindow and two Panel Components and
edit their characteristics.
-setPreferredSize(Vec2f): Determine the
size of the Panel.
-pushToChildren(ComponentName):
Adds a Component to the
ComponentContainer as a Child (meaning it
will be displayed within it).
-setLayout(LayoutName): Determines the
Layout of the ComponentContainer.
******************************************************/
InternalWindowRecPtr MainInternalWindow = InternalWindow::create();
PanelRecPtr ExamplePanel1 = Panel::create();
PanelRecPtr ExamplePanel2 = Panel::create();
// Edit Panel1, Panel2
ExamplePanel1->setPreferredSize(Vec2f(200, 200));
ExamplePanel1->pushToChildren(ExampleButton1);
ExamplePanel1->pushToChildren(ExampleButton2);
ExamplePanel1->pushToChildren(ExampleButton3);
ExamplePanel1->setLayout(ExamplePanel1Layout);
ExamplePanel1->setBackgrounds(ExamplePanelBackground);
ExamplePanel1->setBorders(ExamplePanelBorder);
ExamplePanel2->setPreferredSize(Vec2f(200, 200));
ExamplePanel2->pushToChildren(ExampleButton4);
ExamplePanel2->pushToChildren(ExampleButton5);
ExamplePanel2->pushToChildren(ExampleButton6);
ExamplePanel2->setLayout(ExamplePanel2Layout);
ExamplePanel2->setBackgrounds(ExamplePanelBackground);
ExamplePanel2->setBorders(ExamplePanelBorder);
// Create The Main InternalWindow
MainInternalWindow->pushToChildren(ExamplePanel1);
MainInternalWindow->pushToChildren(ExamplePanel2);
MainInternalWindow->setLayout(MainInternalWindowLayout);
MainInternalWindow->setBackgrounds(MainInternalWindowBackground);
MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setScalingInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setDrawTitlebar(false);
MainInternalWindow->setResizable(false);
MainInternalWindow->setAllInsets(5);
// Create the Drawing Surface
UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRecPtr TutorialUIForeground = UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
// Tell the Manager what to manage
sceneManager.setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRecPtr TutorialViewport = sceneManager.getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
// Show the whole Scene
sceneManager.showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"10Container");
//Enter main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
// 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;
}
// Initialize GLUT & OpenSG and set up the scene
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
{
// Set up Window
WindowEventProducerRecPtr TutorialWindow = createNativeWindow();
//Initialize Window
TutorialWindow->initWindow();
SimpleSceneManager sceneManager;
TutorialWindow->setDisplayCallback(boost::bind(display, &sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, &sceneManager));
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
//Attach to events
TutorialWindow->connectMousePressed(boost::bind(mousePressed, _1, &sceneManager));
TutorialWindow->connectMouseReleased(boost::bind(mouseReleased, _1, &sceneManager));
TutorialWindow->connectMouseDragged(boost::bind(mouseDragged, _1, &sceneManager));
TutorialWindow->connectMouseWheelMoved(boost::bind(mouseWheelMoved, _1, &sceneManager));
BoostPath FilePath("../Animation/Data/Nanobot.dae");
if(argc >= 2)
{
FilePath = BoostPath(argv[1]);
if(!boost::filesystem::exists(FilePath))
{
std::cerr << "Could not load file: "<< FilePath.string()
<< ", because no such files exists."<< std::endl;
FilePath = BoostPath("../Animation/Data/Nanobot.dae");
}
}
NodeRefPtr LoadedRoot;
std::vector<AnimationRecPtr> LoadedAnimations;
FCFileType::FCPtrStore ObjStore;
try
{
ObjStore = FCFileHandler::the()->read(FilePath);
}
catch(std::exception &ex)
{
std::cerr << "Failed to load file: " << FilePath.string() << ", error:"
<< ex.what() << std::endl;
return -1;
}
for(FCFileType::FCPtrStore::iterator StorItor(ObjStore.begin());
StorItor != ObjStore.end();
++StorItor)
{
//Animations
if((*StorItor)->getType().isDerivedFrom(Animation::getClassType()))
{
LoadedAnimations.push_back(dynamic_pointer_cast<Animation>(*StorItor));
LoadedAnimations.back()->attachUpdateProducer(TutorialWindow);
LoadedAnimations.back()->start();
}
//Root Node
if((*StorItor)->getType() == Node::getClassType() &&
dynamic_pointer_cast<Node>(*StorItor)->getParent() == NULL)
{
LoadedRoot = dynamic_pointer_cast<Node>(*StorItor);
}
}
if(LoadedRoot == NULL)
{
LoadedRoot = SceneFileHandler::the()->read(FilePath.string().c_str());
}
if(LoadedRoot == NULL)
{
LoadedRoot= makeTorus(.5, 2, 32, 32);
}
//Make the fog node
PostShaderStageRecPtr PostShaderStageCore = PostShaderStage::create();
PostShaderStageCore->clearPasses();
PostShaderStageCore->addPass("", generateNoEffectProg());
DirectionalLightRecPtr SceneLightCore = DirectionalLight::create();
SceneLightCore->setAmbient(Color4f(0.2f, 0.2f, 0.2f, 1.0f));
SceneLightCore->setDiffuse(Color4f(0.8f, 0.8f, 0.8f, 1.0f));
SceneLightCore->setSpecular(Color4f(1.0f, 1.0f, 1.0f, 1.0f));
NodeRefPtr SceneLight = makeNodeFor(SceneLightCore);
SceneLight->addChild(LoadedRoot);
NodeRefPtr PostShaderStageNode = makeNodeFor(PostShaderStageCore);
PostShaderStageNode->addChild(SceneLight);
//Make Main Scene Node
NodeRefPtr scene = makeCoredNode<Group>();
scene->addChild(PostShaderStageNode);
// tell the manager what to manage
sceneManager.setRoot (scene);
SceneLightCore->setBeacon(sceneManager.getCamera()->getBeacon());
//Create the Documentation Foreground and add it to the viewport
SimpleScreenDoc TheSimpleScreenDoc(&sceneManager, TutorialWindow);
// show the whole scene
sceneManager.showAll();
sceneManager.getWindow()->getPort(0)->setTravMask(1);
RenderOptionsRecPtr ViewportRenderOptions = RenderOptions::create();
ViewportRenderOptions->setRenderProperties(0x0);
ViewportRenderOptions->setRenderProperties(RenderPropertiesPool::the()->getFrom1("Default"));
ViewportRenderOptions->setRenderProperties(0x01);
sceneManager.getWindow()->getPort(0)->setRenderOptions(ViewportRenderOptions);
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"Collada Loader");
TutorialWindow->connectKeyPressed(boost::bind(keyPressed, _1,
TutorialWindow.get(),
PostShaderStageCore.get()));
//Enter main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
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;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
{
// Set up Window
WindowEventProducerRecPtr TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
// Create the SimpleSceneManager helper
SimpleSceneManager sceneManager;
TutorialWindow->setDisplayCallback(boost::bind(display, &sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, &sceneManager));
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
TutorialWindow->connectKeyTyped(boost::bind(keyPressed, _1));
// Make Torus Node (creates Torus in background of scene)
NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRecPtr scene = Node::create();
scene->setCore(Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRecPtr TutorialGraphics = Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
/******************************************************
Create a RotatedComponent.
-setAngle(Angle, in radians): Determine
the angle the Component initially
is rotated.
-setInternalComponent(Component):
Determine what Component will
be rotated.
-setResizePolicy(RotatedComponent::ENUM):
Takes NO_RESIZING, RESIZE_TO_MIN, or
RESIZE_TO_MAX arguments.
******************************************************/
RotatedComponentRecPtr TheRotatedComponent = RotatedComponent::create();
// Define PI
Real32 PI(3.14159);
TheRotatedComponent->setAngle(PI/4);
ComponentRecPtr InnerPanel = createPanel();
TheRotatedComponent->setInternalComponent(InnerPanel);
TheRotatedComponent->setResizePolicy(RotatedComponent::RESIZE_TO_MIN);
/******************************************************
Create a ToggleButton which can
be used to start and stop the
Button from rotating.
Note: due to the way FlowLayout works
you will notice that this ToggleButton
will move as well. In cases where
a Rotating Component is used, an
alternate Layout may be preferred
to prevent other Components from
moving as well. This is
intentionally left this way to
illustrate why this might be the case.
A SplitPanel with fixed divider for
example would prevent the ToggleButton
from moving, while still allowing the
Panel to move freely.
******************************************************/
ToggleButtonRecPtr RotateControlButton = ToggleButton::create();
RotateControlButton->setText("Start Rotating");
RotateControlButton->setPreferredSize(Vec2f(100.0f, 29.0f));
RotateControlButton->connectButtonSelected(boost::bind(handleButtonSelected, _1,
TutorialWindow.get(),
TheRotatedComponent.get()));
RotateControlButton->connectButtonDeselected(boost::bind(handleButtonDeselected, _1,
TutorialWindow.get(),
TheRotatedComponent.get()));
// Create The Main InternalWindow
// Create Background to be used with the Main InternalWindow
ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
LayoutRecPtr MainInternalWindowLayout = FlowLayout::create();
InternalWindowRecPtr MainInternalWindow = InternalWindow::create();
MainInternalWindow->pushToChildren(TheRotatedComponent);
MainInternalWindow->pushToChildren(RotateControlButton);
MainInternalWindow->setLayout(MainInternalWindowLayout);
MainInternalWindow->setBackgrounds(MainInternalWindowBackground);
MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setScalingInDrawingSurface(Vec2f(0.8f,0.8f));
MainInternalWindow->setDrawTitlebar(false);
MainInternalWindow->setResizable(false);
// Create the Drawing Surface
UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRecPtr TutorialUIForeground = UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
// Tell the Manager what to manage
sceneManager.setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRecPtr TutorialViewport = sceneManager.getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
//Create the Documentation Foreground and add it to the viewport
SimpleScreenDoc TheSimpleScreenDoc(&sceneManager, TutorialWindow);
// Show the whole Scene
sceneManager.showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"30RotatedComponent");
//Enter main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
// Initialize GLUT & OpenSG and set up the scene
int main(int argc, char **argv)
{
OSG::preloadSharedObject("OSGFileIO");
OSG::preloadSharedObject("OSGImageFileIO");
// OSG init
osgInit(argc,argv);
{
// Set up Window
WindowEventProducerRecPtr TutorialWindow = createNativeWindow();
//Initialize Window
TutorialWindow->initWindow();
SimpleSceneManager sceneManager;
TutorialWindow->setDisplayCallback(boost::bind(display, &sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, &sceneManager));
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
//Attach to events
TutorialWindow->connectMousePressed(boost::bind(mousePressed, _1, &sceneManager));
TutorialWindow->connectMouseReleased(boost::bind(mouseReleased, _1, &sceneManager));
TutorialWindow->connectMouseDragged(boost::bind(mouseDragged, _1, &sceneManager));
TutorialWindow->connectMouseWheelMoved(boost::bind(mouseWheelMoved, _1, &sceneManager));
TutorialWindow->connectKeyPressed(boost::bind(keyPressed, _1, TutorialWindow.get()));
//Box Geometry
GeometryUnrecPtr BoxGeometry = makeBoxGeo(1.0,1.0,1.0,1,1,1);
ChunkMaterialUnrecPtr TheBoxMaterial = ChunkMaterial::create();
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);
//Setup the Animation
AnimationUnrecPtr TheAnimation = setupAnimation(TheBoxMaterial);
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();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"09TextureSelectAnimation");
//Main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
