// Initialize GLUT & OpenSG and set up the scene
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
// Set up Window
TutorialWindowEventProducer = createDefaultWindowEventProducer();
WindowPtr MainWindow = TutorialWindowEventProducer->initWindow();
TutorialWindowEventProducer->setDisplayCallback(display);
TutorialWindowEventProducer->setReshapeCallback(reshape);
//Add Window Listener
TutorialKeyListener TheKeyListener;
TutorialWindowEventProducer->addKeyListener(&TheKeyListener);
TutorialMouseListener TheTutorialMouseListener;
TutorialMouseMotionListener TheTutorialMouseMotionListener;
TutorialWindowEventProducer->addMouseListener(&TheTutorialMouseListener);
TutorialWindowEventProducer->addMouseMotionListener(&TheTutorialMouseMotionListener);
// Create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// Tell the Manager what to manage
mgr->setWindow(TutorialWindowEventProducer->getWindow());
Path FBOFilePath;
if(argc < 2)
{
FWARNING(("No FBO file given!\n"));
FBOFilePath = Path("./Data/01LoadFBO.xml");
}
else
{
FBOFilePath = Path(std::string(argv[1]));
}
std::cout << "Loading xml File: " << FBOFilePath << std::endl;
FCFileType::FCPtrStore NewContainers;
NewContainers = FCFileHandler::the()->read(FBOFilePath);
FCFileType::FCPtrStore::iterator Itor;
for(Itor = NewContainers.begin() ; Itor != NewContainers.end() ; ++Itor)
{
if( (*Itor)->getType() == FBOViewport::getClassType())
{
TheFBOViewport = FBOViewport::Ptr::dcast(*Itor);
}
}
ChunkMaterialPtr BoxMaterial = ChunkMaterial::create();
GeometryPtr BoxGeoCore = makeBoxGeo(1.0,1.0,1.0,2,2,2);
beginEditCP(BoxGeoCore, Geometry::MaterialFieldMask);
BoxGeoCore->setMaterial(BoxMaterial);
endEditCP(BoxGeoCore, Geometry::MaterialFieldMask);
NodePtr BoxGeoNode = Node::create();
beginEditCP(BoxGeoNode, Node::CoreFieldMask);
BoxGeoNode->setCore(BoxGeoCore);
endEditCP(BoxGeoNode, Node::CoreFieldMask);
NodePtr SceneNode = Node::create();
beginEditCP(SceneNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
SceneNode->setCore(Group::create());
SceneNode->addChild(BoxGeoNode);
endEditCP(SceneNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
// tell the manager what to manage
mgr->setRoot (SceneNode);
// show the whole scene
mgr->showAll();
if(TheFBOViewport != NullFC)
{
//Add the texture chunk of the FBO to the Material for the box
beginEditCP(BoxMaterial, ChunkMaterial::ChunksFieldMask);
BoxMaterial->addChunk(TheFBOViewport->editTextures(0));
endEditCP(BoxMaterial, ChunkMaterial::ChunksFieldMask);
//Add The FBO Viewport the the Window
beginEditCP(TheFBOViewport, FBOViewport::ParentFieldMask);
TheFBOViewport->setParent(TutorialWindowEventProducer->getWindow());
endEditCP(TheFBOViewport, FBOViewport::ParentFieldMask);
beginEditCP(TutorialWindowEventProducer->getWindow());
ViewportPtr vp = TutorialWindowEventProducer->getWindow()->getPort(0);
addRefCP(vp);
TutorialWindowEventProducer->getWindow()->subPort(0);
//Put the FBO Vieport in front, so it is rendered first
TutorialWindowEventProducer->getWindow()->addPort(TheFBOViewport);
TutorialWindowEventProducer->getWindow()->addPort(vp );
endEditCP (TutorialWindowEventProducer->getWindow());
}
Vec2f WinSize(TutorialWindowEventProducer->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindowEventProducer->getDesktopSize() - WinSize) *0.5);
TutorialWindowEventProducer->openWindow(WinPos,
WinSize,
"07LoadFBO");
//Main Loop
TutorialWindowEventProducer->mainLoop();
osgExit();
return 0;
}
// Initialize GLUT & OpenSG and set up the rootNode
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
// Set up Window
TutorialWindowEventProducer = createDefaultWindowEventProducer();
WindowPtr MainWindow = TutorialWindowEventProducer->initWindow();
TutorialWindowEventProducer->setDisplayCallback(display);
TutorialWindowEventProducer->setReshapeCallback(reshape);
TutorialKeyListener TheKeyListener;
TutorialWindowEventProducer->addKeyListener(&TheKeyListener);
TutorialMouseListener TheTutorialMouseListener;
TutorialMouseMotionListener TheTutorialMouseMotionListener;
TutorialWindowEventProducer->addMouseListener(&TheTutorialMouseListener);
TutorialWindowEventProducer->addMouseMotionListener(&TheTutorialMouseMotionListener);
// Create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// Tell the Manager what to manage
mgr->setWindow(TutorialWindowEventProducer->getWindow());
//Make Torus Node
TriGeometryBase = makeTorus(.55, 1.5, 16, 16);
//Make Main Scene Node
NodePtr scene = makeCoredNode<Group>();
setName(scene, "scene");
rootNode = Node::create();
setName(rootNode, "rootNode");
ComponentTransformPtr Trans;
Trans = ComponentTransform::create();
beginEditCP(rootNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
rootNode->setCore(Trans);
// add the torus as a child
rootNode->addChild(scene);
endEditCP (rootNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
//Setup Physics Scene
physicsWorld = PhysicsWorld::create();
beginEditCP(physicsWorld, PhysicsWorld::WorldContactSurfaceLayerFieldMask |
PhysicsWorld::AutoDisableFlagFieldMask |
PhysicsWorld::AutoDisableTimeFieldMask |
PhysicsWorld::WorldContactMaxCorrectingVelFieldMask |
PhysicsWorld::GravityFieldMask);
physicsWorld->setWorldContactSurfaceLayer(0.005);
physicsWorld->setAutoDisableFlag(1);
physicsWorld->setAutoDisableTime(0.75);
physicsWorld->setWorldContactMaxCorrectingVel(100.0);
physicsWorld->setGravity(Vec3f(0.0, 0.0, -9.81));
endEditCP(physicsWorld, PhysicsWorld::WorldContactSurfaceLayerFieldMask |
PhysicsWorld::AutoDisableFlagFieldMask |
PhysicsWorld::AutoDisableTimeFieldMask |
PhysicsWorld::WorldContactMaxCorrectingVelFieldMask |
PhysicsWorld::GravityFieldMask);
//Create the Collision Space
physicsSpace = PhysicsHashSpace::create();
//Setup the default collision parameters
CollisionContactParametersPtr DefaultCollisionParams = CollisionContactParameters::createEmpty();
beginEditCP(DefaultCollisionParams);
DefaultCollisionParams->setMode(dContactApprox1);
DefaultCollisionParams->setMu(0.3);
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);
endEditCP(DefaultCollisionParams);
beginEditCP(physicsSpace, PhysicsSpace::DefaultCollisionParametersFieldMask);
physicsSpace->setDefaultCollisionParameters(DefaultCollisionParams);
endEditCP(physicsSpace, PhysicsSpace::DefaultCollisionParametersFieldMask);
//Bouncy Sphere collision parameters
CollisionContactParametersPtr BouncySphereCollisionParams = CollisionContactParameters::createEmpty();
beginEditCP(BouncySphereCollisionParams);
BouncySphereCollisionParams->setMode(dContactApprox1 | dContactBounce);
BouncySphereCollisionParams->setMu(0.3);
BouncySphereCollisionParams->setMu2(0.0);
BouncySphereCollisionParams->setBounce(0.8);
BouncySphereCollisionParams->setBounceSpeedThreshold(0.1);
BouncySphereCollisionParams->setSoftCFM(0.1);
BouncySphereCollisionParams->setSoftERP(0.2);
BouncySphereCollisionParams->setMotion1(0.0);
BouncySphereCollisionParams->setMotion2(0.0);
BouncySphereCollisionParams->setMotionN(0.0);
BouncySphereCollisionParams->setSlip1(0.0);
BouncySphereCollisionParams->setSlip2(0.0);
endEditCP(BouncySphereCollisionParams);
physicsSpace->addCollisionContactCategory(SphereCategory, TerrainCategory, BouncySphereCollisionParams);
physicsSpace->addCollisionContactCategory(SphereCategory, BoxCategory, BouncySphereCollisionParams);
physicsSpace->addCollisionContactCategory(SphereCategory, SphereCategory, BouncySphereCollisionParams);
physicsSpace->addCollisionContactCategory(SphereCategory, TriCategory, BouncySphereCollisionParams);
//Soft Box collision parameters
CollisionContactParametersPtr SlickBoxParams = CollisionContactParameters::createEmpty();
beginEditCP(SlickBoxParams);
SlickBoxParams->setMode(dContactApprox1);
SlickBoxParams->setMu(0.01);
SlickBoxParams->setMu2(0.0);
SlickBoxParams->setBounce(0.0);
SlickBoxParams->setBounceSpeedThreshold(0.0);
SlickBoxParams->setSoftCFM(0.0);
SlickBoxParams->setSoftERP(0.2);
SlickBoxParams->setMotion1(0.0);
SlickBoxParams->setMotion2(0.0);
SlickBoxParams->setMotionN(0.0);
SlickBoxParams->setSlip1(0.0);
SlickBoxParams->setSlip2(0.0);
endEditCP(SlickBoxParams);
physicsSpace->addCollisionContactCategory(BoxCategory, TerrainCategory, SlickBoxParams);
physicsSpace->addCollisionContactCategory(BoxCategory, BoxCategory, SlickBoxParams);
//physicsSpace->addCollisionContactCategory(BoxCategory, SphereCategory, SlickBoxParams);
physicsSpace->addCollisionContactCategory(BoxCategory, TriCategory, SlickBoxParams);
TutorialCollisionListener BoxColListener(Path("./Data/click.wav"));
physicsSpace->addCollisionListener(&BoxColListener,BoxCategory, 2.0);
TutorialCollisionListener SphereColListener(Path("./Data/pop.wav"));
physicsSpace->addCollisionListener(&SphereColListener,SphereCategory, 2.0);
physHandler = PhysicsHandler::create();
beginEditCP(physHandler, PhysicsHandler::WorldFieldMask | PhysicsHandler::SpacesFieldMask | PhysicsHandler::StepSizeFieldMask | PhysicsHandler::UpdateNodeFieldMask);
physHandler->setWorld(physicsWorld);
physHandler->getSpaces().push_back(physicsSpace);
physHandler->setStepSize(0.001);
physHandler->setUpdateNode(rootNode);
endEditCP(physHandler, PhysicsHandler::WorldFieldMask | PhysicsHandler::SpacesFieldMask | PhysicsHandler::StepSizeFieldMask | PhysicsHandler::UpdateNodeFieldMask);
physHandler->attachUpdateProducer(TutorialWindowEventProducer);
beginEditCP(rootNode, Node::AttachmentsFieldMask);
rootNode->addAttachment(physHandler);
rootNode->addAttachment(physicsWorld);
rootNode->addAttachment(physicsSpace);
endEditCP(rootNode, Node::AttachmentsFieldMask);
/************************************************************************/
/* create spaces, geoms and bodys */
/************************************************************************/
//create a group for our space
GroupPtr spaceGroup;
spaceGroupNode = makeCoredNode<Group>(&spaceGroup);
//create the ground plane
GeometryPtr plane;
NodePtr planeNode = makeBox(30.0, 30.0, 1.0, 1, 1, 1);
plane = GeometryPtr::dcast(planeNode->getCore());
//and its Material
SimpleMaterialPtr plane_mat = SimpleMaterial::create();
beginEditCP(plane_mat);
plane_mat->setAmbient(Color3f(0.7,0.7,0.7));
plane_mat->setDiffuse(Color3f(0.9,0.6,1.0));
endEditCP(plane_mat);
beginEditCP(plane, Geometry::MaterialFieldMask);
plane->setMaterial(plane_mat);
endEditCP(plane);
//create Physical Attachments
PhysicsBoxGeomPtr planeGeom = PhysicsBoxGeom::create();
beginEditCP(planeGeom, PhysicsBoxGeom::LengthsFieldMask | PhysicsBoxGeom::SpaceFieldMask | PhysicsBoxGeom::CategoryBitsFieldMask);
planeGeom->setLengths(Vec3f(30.0, 30.0, 1.0));
//add geoms to space for collision
planeGeom->setSpace(physicsSpace);
//Set the Geoms Category - this will be used by the collision space
//for determining if collision tests should occur
//and for selecting the collision contact parameters when a collision does occur
planeGeom->setCategoryBits(TerrainCategory);
endEditCP(planeGeom, PhysicsBoxGeom::LengthsFieldMask | PhysicsBoxGeom::SpaceFieldMask | PhysicsBoxGeom::CategoryBitsFieldMask);
//add Attachments to nodes...
beginEditCP(spaceGroupNode, Node::AttachmentsFieldMask | Node::ChildrenFieldMask);
spaceGroupNode->addAttachment(physicsSpace);
spaceGroupNode->addChild(planeNode);
endEditCP(spaceGroupNode, Node::AttachmentsFieldMask | Node::ChildrenFieldMask);
beginEditCP(planeNode, Node::AttachmentsFieldMask);
planeNode->addAttachment(planeGeom);
endEditCP(planeNode, Node::AttachmentsFieldMask);
beginEditCP(scene, Node::ChildrenFieldMask);
scene->addChild(spaceGroupNode);
endEditCP(scene, Node::ChildrenFieldMask);
//Create Statistics Foreground
SimpleStatisticsForegroundPtr PhysicsStatForeground = SimpleStatisticsForeground::create();
beginEditCP(PhysicsStatForeground);
PhysicsStatForeground->setSize(25);
PhysicsStatForeground->setColor(Color4f(0,1,0,0.7));
PhysicsStatForeground->addElement(PhysicsHandler::statPhysicsTime,
"Physics time: %.3f s");
PhysicsStatForeground->addElement(PhysicsHandler::statCollisionTime,
"Collision time: %.3f s");
PhysicsStatForeground->addElement(PhysicsHandler::statSimulationTime,
"Simulation time: %.3f s");
PhysicsStatForeground->addElement(PhysicsHandler::statNCollisions,
"%d collisions");
PhysicsStatForeground->addElement(PhysicsHandler::statNCollisionTests,
"%d collision tests");
PhysicsStatForeground->addElement(PhysicsHandler::statNPhysicsSteps,
"%d simulation steps per frame");
endEditCP(PhysicsStatForeground);
// tell the manager what to manage
mgr->setRoot (rootNode);
beginEditCP(mgr->getWindow()->getPort(0), Viewport::ForegroundsFieldMask);
mgr->getWindow()->getPort(0)->getForegrounds().push_back(PhysicsStatForeground);
endEditCP(mgr->getWindow()->getPort(0), Viewport::ForegroundsFieldMask);
physHandler->setStatistics(&PhysicsStatForeground->getCollector());
// show the whole rootNode
mgr->showAll();
//Attach the Sound Manager to the update and the camera
SoundManager::the()->attachUpdateProducer(TutorialWindowEventProducer);
SoundManager::the()->setCamera(mgr->getCamera());
Vec2f WinSize(TutorialWindowEventProducer->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindowEventProducer->getDesktopSize() - WinSize) *0.5);
TutorialWindowEventProducer->openWindow(WinPos,
WinSize,
"21Collisions");
//Enter main Loop
TutorialWindowEventProducer->mainLoop();
osgExit();
return 0;
}
// Initialize GLUT & OpenSG and set up the scene
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
// Set up Window
TutorialWindowEventProducer = createDefaultWindowEventProducer();
WindowPtr MainWindow = TutorialWindowEventProducer->initWindow();
TutorialWindowEventProducer->setDisplayCallback(display);
TutorialWindowEventProducer->setReshapeCallback(reshape);
//Add Window Listener
TutorialKeyListener TheKeyListener;
TutorialWindowEventProducer->addKeyListener(&TheKeyListener);
TutorialMouseListener TheTutorialMouseListener;
TutorialMouseMotionListener TheTutorialMouseMotionListener;
TutorialWindowEventProducer->addMouseListener(&TheTutorialMouseListener);
TutorialWindowEventProducer->addMouseMotionListener(&TheTutorialMouseMotionListener);
TutorialUpdateListener TheTutorialUpdateListener;
TutorialWindowEventProducer->addUpdateListener(&TheTutorialUpdateListener);
// Create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// Tell the Manager what to manage
mgr->setWindow(TutorialWindowEventProducer->getWindow());
////////////////
// Create the Graphics
GraphicsPtr TutorialGraphics = osg::Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
/******************************************************
Create an Button Component and
a simple Font.
See 17Label_Font for more
information about Fonts.
******************************************************/
ButtonPtr ExampleButton = osg::Button::create();
UIFontPtr ExampleFont = osg::UIFont::create();
beginEditCP(ExampleButton, Button::MinSizeFieldMask | Button::MaxSizeFieldMask | Button::PreferredSizeFieldMask | Button::ToolTipTextFieldMask | Button::TextFieldMask |
Button::FontFieldMask | Button::TextColorFieldMask | Button::RolloverTextColorFieldMask | Button::ActiveTextColorFieldMask | Button::AlignmentFieldMask);
ExampleButton->setMinSize(Vec2f(50, 25));
ExampleButton->setMaxSize(Vec2f(200, 100));
ExampleButton->setPreferredSize(Vec2f(100, 50));
ExampleButton->setToolTipText("Click to start/pause");
ExampleButton->setText("start/pause");
ExampleButton->setFont(ExampleFont);
ExampleButton->setTextColor(Color4f(1.0, 0.0, 0.0, 1.0));
ExampleButton->setRolloverTextColor(Color4f(1.0, 0.0, 1.0, 1.0));
ExampleButton->setActiveTextColor(Color4f(1.0, 0.0, 0.0, 1.0));
ExampleButton->setAlignment(Vec2f(.5,0.5));
endEditCP(ExampleButton, Button::MinSizeFieldMask | Button::MaxSizeFieldMask | Button::PreferredSizeFieldMask | Button::ToolTipTextFieldMask | Button::TextFieldMask |
Button::FontFieldMask | Button::TextColorFieldMask | Button::RolloverTextColorFieldMask | Button::ActiveTextColorFieldMask | Button::AlignmentFieldMask);
// Create an ActionListener and assign it to ExampleButton
// This Class is defined above, and will cause the output
// window to display "Button 1 Action" when pressed
ExampleButtonActionListener TheExampleButtonActionListener;
ExampleButton->addActionListener(&TheExampleButtonActionListener);
//////////////////
//Torus Material
TheTorusMaterial = SimpleMaterial::create();
beginEditCP(TheTorusMaterial);
SimpleMaterialPtr::dcast(TheTorusMaterial)->setAmbient(Color3f(0.3,0.3,0.3));
SimpleMaterialPtr::dcast(TheTorusMaterial)->setDiffuse(Color3f(0.7,0.7,0.7));
SimpleMaterialPtr::dcast(TheTorusMaterial)->setSpecular(Color3f(1.0,1.0,1.0));
endEditCP(TheTorusMaterial);
//Torus Geometry
GeometryPtr TorusGeometry = makeTorusGeo(.5, 2, 32, 32);
beginEditCP(TorusGeometry);
TorusGeometry->setMaterial(TheTorusMaterial);
endEditCP (TorusGeometry);
NodePtr TorusGeometryNode = Node::create();
beginEditCP(TorusGeometryNode, Node::CoreFieldMask);
TorusGeometryNode->setCore(TorusGeometry);
endEditCP (TorusGeometryNode, Node::CoreFieldMask);
//Make Torus Node
NodePtr TorusNode = Node::create();
TransformPtr TorusNodeTrans;
TorusNodeTrans = Transform::create();
setName(TorusNodeTrans, std::string("TorusNodeTransformationCore"));
beginEditCP(TorusNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
TorusNode->setCore(TorusNodeTrans);
TorusNode->addChild(TorusGeometryNode);
endEditCP (TorusNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
//Make Main Scene Node
NodePtr scene = Node::create();
ComponentTransformPtr Trans;
Trans = ComponentTransform::create();
setName(Trans, std::string("MainTransformationCore"));
beginEditCP(scene, Node::CoreFieldMask | Node::ChildrenFieldMask);
{
scene->setCore(Trans);
// add the torus as a child
scene->addChild(TorusNode);
}
endEditCP (scene, Node::CoreFieldMask | Node::ChildrenFieldMask);
setupAnimation();
// Create Background to be used with the Main InternalWindow
ColorLayerPtr MainInternalWindowBackground = osg::ColorLayer::create();
beginEditCP(MainInternalWindowBackground, ColorLayer::ColorFieldMask);
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
endEditCP(MainInternalWindowBackground, ColorLayer::ColorFieldMask);
InternalWindowPtr MainInternalWindow = osg::InternalWindow::create();
LayoutPtr MainInternalWindowLayout = osg::FlowLayout::create();
beginEditCP(MainInternalWindow, InternalWindow::ChildrenFieldMask | InternalWindow::LayoutFieldMask | InternalWindow::BackgroundsFieldMask | InternalWindow::AlignmentInDrawingSurfaceFieldMask | InternalWindow::ScalingInDrawingSurfaceFieldMask | InternalWindow::DrawTitlebarFieldMask | InternalWindow::ResizableFieldMask);
MainInternalWindow->getChildren().push_back(ExampleButton);
MainInternalWindow->setLayout(MainInternalWindowLayout);
MainInternalWindow->setBackgrounds(MainInternalWindowBackground);
MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setScalingInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setDrawTitlebar(false);
MainInternalWindow->setResizable(false);
endEditCP(MainInternalWindow, InternalWindow::ChildrenFieldMask | InternalWindow::LayoutFieldMask | InternalWindow::BackgroundsFieldMask | InternalWindow::AlignmentInDrawingSurfaceFieldMask | InternalWindow::ScalingInDrawingSurfaceFieldMask | InternalWindow::DrawTitlebarFieldMask | InternalWindow::ResizableFieldMask);
// Create the Drawing Surface
UIDrawingSurfacePtr TutorialDrawingSurface = UIDrawingSurface::create();
beginEditCP(TutorialDrawingSurface, UIDrawingSurface::GraphicsFieldMask | UIDrawingSurface::EventProducerFieldMask);
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindowEventProducer);
endEditCP(TutorialDrawingSurface, UIDrawingSurface::GraphicsFieldMask | UIDrawingSurface::EventProducerFieldMask);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundPtr TutorialUIForeground = osg::UIForeground::create();
beginEditCP(TutorialUIForeground, UIForeground::DrawingSurfaceFieldMask);
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
endEditCP(TutorialUIForeground, UIForeground::DrawingSurfaceFieldMask);
mgr->setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportPtr TutorialViewport = mgr->getWindow()->getPort(0);
beginEditCP(TutorialViewport, Viewport::ForegroundsFieldMask);
TutorialViewport->getForegrounds().push_back(TutorialUIForeground);
beginEditCP(TutorialViewport, Viewport::ForegroundsFieldMask);
// show the whole scene
mgr->showAll();
TheAnimationAdvancer->start();
Vec2f WinSize(TutorialWindowEventProducer->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindowEventProducer->getDesktopSize() - WinSize) *0.5);
TutorialWindowEventProducer->openWindow(WinPos,
WinSize,
"24AnimationAction");
//Enter main Loop
TutorialWindowEventProducer->mainLoop();
osgExit();
return 0;
}
// Initialize GLUT & OpenSG and set up the scene
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
// Set up Window
TutorialWindowEventProducer = createDefaultWindowEventProducer();
WindowPtr MainWindow = TutorialWindowEventProducer->initWindow();
TutorialWindowEventProducer->setDisplayCallback(display);
TutorialWindowEventProducer->setReshapeCallback(reshape);
//Add Window Listener
TutorialKeyListener TheKeyListener;
TutorialWindowEventProducer->addKeyListener(&TheKeyListener);
TutorialMouseListener TheTutorialMouseListener;
TutorialMouseMotionListener TheTutorialMouseMotionListener;
TutorialWindowEventProducer->addMouseListener(&TheTutorialMouseListener);
TutorialWindowEventProducer->addMouseMotionListener(&TheTutorialMouseMotionListener);
// Create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// Tell the Manager what to manage
mgr->setWindow(TutorialWindowEventProducer->getWindow());
//Make a SphereNode for the point light
LambertMaterialPtr TheLightMat = LambertMaterial::create();
beginEditCP(TheLightMat, LambertMaterial::IncandescenceFieldMask);
TheLightMat->setIncandescence(Color3f(1.0,1.0,1.0));
endEditCP(TheLightMat, LambertMaterial::IncandescenceFieldMask);
GeometryPtr LightSphereGeo = makeSphereGeo(2,2.0);
beginEditCP(LightSphereGeo, Geometry::MaterialFieldMask);
LightSphereGeo->setMaterial(TheLightMat);
endEditCP (LightSphereGeo, Geometry::MaterialFieldMask);
NodePtr LightSphereNode = Node::create();
beginEditCP(LightSphereNode, Node::CoreFieldMask);
LightSphereNode->setCore(LightSphereGeo);
endEditCP (LightSphereNode, Node::CoreFieldMask);
//Create the beacon for the Point Light
Matrix ThePointLightMat;
ThePointLightMat.setTranslate(Vec3f(0.0,100.0,0.0));
ThePointLightBeaconTransform = Transform::create();
beginEditCP(ThePointLightBeaconTransform);
ThePointLightBeaconTransform->setMatrix(ThePointLightMat);
endEditCP(ThePointLightBeaconTransform);
NodePtr ThePointLightBeaconNode = Node::create();
beginEditCP(ThePointLightBeaconNode);
ThePointLightBeaconNode->setCore(ThePointLightBeaconTransform);
ThePointLightBeaconNode->addChild(LightSphereNode);
endEditCP(ThePointLightBeaconNode);
//Set the light properties desired
PointLightPtr ThePointLight = PointLight::create();
beginEditCP(ThePointLight);
ThePointLight->setAmbient(0.3,0.3,0.3,0.3);
ThePointLight->setDiffuse(1.0,1.0,1.0,1.0);
ThePointLight->setSpecular(1.0,1.0,1.0,1.0);
ThePointLight->setBeacon(ThePointLightBeaconNode);
endEditCP(ThePointLight);
NodePtr ThePointLightNode = Node::create();
beginEditCP(ThePointLightNode);
ThePointLightNode->setCore(ThePointLight);
endEditCP(ThePointLightNode);
//Set the light properties desired
SpotLightPtr TheSpotLight = SpotLight::create();
beginEditCP(TheSpotLight);
TheSpotLight->setAmbient(0.3,0.3,0.3,0.3);
TheSpotLight->setDiffuse(1.0,1.0,1.0,1.0);
TheSpotLight->setSpecular(1.0,1.0,1.0,1.0);
TheSpotLight->setBeacon(ThePointLightBeaconNode);
TheSpotLight->setDirection(Vec3f(0.0,-1.0,0.0));
TheSpotLight->setSpotExponent(5.0);
TheSpotLight->setSpotCutOff(1.1);
endEditCP(TheSpotLight);
NodePtr TheSpotLightNode = Node::create();
beginEditCP(TheSpotLightNode);
TheSpotLightNode->setCore(TheSpotLight);
endEditCP(TheSpotLightNode);
//Load in the Heightmap Image
ImagePtr PerlinNoiseImage = createPerlinImage(Vec2s(256,256), Vec2f(10.0f,10.0f),0.5f,1.0f,Vec2f(0.0f,0.0f),0.25f,6,PERLIN_INTERPOLATE_COSINE,false,Image::OSG_L_PF, Image::OSG_UINT8_IMAGEDATA);
TextureChunkPtr TheTextureChunk = TextureChunk::create();
beginEditCP(TheTextureChunk);
TheTextureChunk->setImage(PerlinNoiseImage);
endEditCP(TheTextureChunk);
//Lambert Material
LambertMaterialPtr TheLambertMat = LambertMaterial::create();
beginEditCP(TheLambertMat, LambertMaterial::ColorFieldMask | LambertMaterial::AmbientColorFieldMask | LambertMaterial::DiffuseFieldMask
| LambertMaterial::NumLightsFieldMask | LambertMaterial::DiffuseTextureFieldMask);
TheLambertMat->setColor(Color3f(0.0,1.0,0.0));
TheLambertMat->setAmbientColor(Color3f(1.0,0.0,0.0));
TheLambertMat->setDiffuse(0.5);
TheLambertMat->setNumLights(1);
endEditCP(TheLambertMat, LambertMaterial::ColorFieldMask | LambertMaterial::AmbientColorFieldMask | LambertMaterial::DiffuseFieldMask
| LambertMaterial::NumLightsFieldMask | LambertMaterial::DiffuseTextureFieldMask);
//Blinn Material
TheBlinnMat = BlinnMaterial::create();
beginEditCP(TheBlinnMat, BlinnMaterial::ColorFieldMask | BlinnMaterial::AmbientColorFieldMask | BlinnMaterial::DiffuseFieldMask
| BlinnMaterial::SpecularColorFieldMask | BlinnMaterial::SpecularEccentricityFieldMask | BlinnMaterial::SpecularRolloffFieldMask | BlinnMaterial::DiffuseTextureFieldMask);
TheBlinnMat->setColor(Color3f(1.0,0.0,0.0));
TheBlinnMat->setAmbientColor(Color3f(0.0,0.0,0.0));
TheBlinnMat->setSpecularColor(Color3f(0.0,0.0,1.0));
TheBlinnMat->setSpecularEccentricity(0.35);
TheBlinnMat->setSpecularRolloff(0.85);
TheBlinnMat->setDiffuse(0.65);
TheBlinnMat->setDiffuseTexture(TheTextureChunk);
endEditCP(TheBlinnMat, BlinnMaterial::ColorFieldMask | BlinnMaterial::AmbientColorFieldMask | BlinnMaterial::DiffuseFieldMask
| BlinnMaterial::SpecularColorFieldMask | BlinnMaterial::SpecularEccentricityFieldMask | BlinnMaterial::SpecularRolloffFieldMask | BlinnMaterial::DiffuseTextureFieldMask);
//Phong Material
Phong2MaterialPtr ThePhongMat = Phong2Material::create();
beginEditCP(ThePhongMat, Phong2Material::ColorFieldMask | Phong2Material::AmbientColorFieldMask | Phong2Material::DiffuseFieldMask
| Phong2Material::SpecularColorFieldMask | Phong2Material::SpecularCosinePowerFieldMask);
ThePhongMat->setColor(Color3f(1.0,0.0,0.0));
ThePhongMat->setAmbientColor(Color3f(0.0,0.0,0.0));
ThePhongMat->setSpecularColor(Color3f(0.0,0.0,1.0));
ThePhongMat->setSpecularCosinePower(50.0);
ThePhongMat->setDiffuse(0.65);
endEditCP(ThePhongMat, Phong2Material::ColorFieldMask | Phong2Material::AmbientColorFieldMask | Phong2Material::DiffuseFieldMask
| Phong2Material::SpecularColorFieldMask | Phong2Material::SpecularCosinePowerFieldMask);
//Anisotropic Material
AnisotropicMaterialPtr TheAnisotropicMat = AnisotropicMaterial::create();
beginEditCP(TheAnisotropicMat, AnisotropicMaterial::ColorFieldMask | AnisotropicMaterial::AmbientColorFieldMask | AnisotropicMaterial::DiffuseFieldMask
| AnisotropicMaterial::SpecularColorFieldMask | AnisotropicMaterial::SpecularRoughnessFieldMask | AnisotropicMaterial::SpecularFresnelIndexFieldMask
| AnisotropicMaterial::SpecularSpreadXFieldMask | AnisotropicMaterial::SpecularSpreadYFieldMask);
TheAnisotropicMat->setColor(Color3f(1.0,0.0,0.0));
TheAnisotropicMat->setAmbientColor(Color3f(0.0,0.0,0.0));
TheAnisotropicMat->setDiffuse(0.65);
TheAnisotropicMat->setSpecularColor(Color3f(0.0,0.0,1.0));
TheAnisotropicMat->setSpecularRoughness(32.0);
TheAnisotropicMat->setSpecularFresnelIndex(0.85);
TheAnisotropicMat->setSpecularSpreadX(1.0);
TheAnisotropicMat->setSpecularSpreadY(1.0);
endEditCP(TheAnisotropicMat, AnisotropicMaterial::ColorFieldMask | AnisotropicMaterial::AmbientColorFieldMask | AnisotropicMaterial::DiffuseFieldMask
| AnisotropicMaterial::SpecularColorFieldMask | AnisotropicMaterial::SpecularRoughnessFieldMask | AnisotropicMaterial::SpecularFresnelIndexFieldMask
| AnisotropicMaterial::SpecularSpreadXFieldMask | AnisotropicMaterial::SpecularSpreadYFieldMask);
PointChunkPtr TempChunk = PointChunk::create();
//addRefCP(TempChunk);
//Anisotropic Material
TheRampMat = RampMaterial::create();
beginEditCP(TheRampMat);
//Color
TheRampMat->setRampSource(RampMaterial::RAMP_SOURCE_FACING_ANGLE);
TheRampMat->getColors().push_back(Color3f(1.0,0.0,0.0));
TheRampMat->getColorPositions().push_back(0.4);
TheRampMat->getColorInterpolations().push_back(RampMaterial::RAMP_INTERPOLATION_SMOOTH);
TheRampMat->getColors().push_back(Color3f(0.0,1.0,0.0));
TheRampMat->getColorPositions().push_back(1.0);
//Transparency
TheRampMat->getTransparencies().push_back(Color3f(0.0,0.0,0.0));
TheRampMat->getTransparencyPositions().push_back(0.83);
TheRampMat->getTransparencyInterpolations().push_back(RampMaterial::RAMP_INTERPOLATION_SMOOTH);
TheRampMat->getTransparencies().push_back(Color3f(1.0,1.0,1.0));
TheRampMat->getTransparencyPositions().push_back(1.0);
TheRampMat->setAmbientColor(Color3f(0.0,0.0,0.0));
TheRampMat->setSpecularity(1.0);
TheRampMat->setSpecularEccentricity(0.8);
TheRampMat->getSpecularColors().push_back(Color3f(1.0,1.0,1.0));
TheRampMat->getSpecularColorPositions().push_back(0.95);
TheRampMat->getSpecularColorInterpolations().push_back(RampMaterial::RAMP_INTERPOLATION_SMOOTH);
TheRampMat->getSpecularColors().push_back(Color3f(0.0,0.0,1.0));
TheRampMat->getSpecularColorPositions().push_back(1.0);
TheRampMat->getSpecularRolloffs().push_back(1.0);
TheRampMat->getExtraChunks().push_back(TempChunk);
endEditCP(TheRampMat);
//Make the Heightmap Geometry
HeightmapGeometryPtr TutorialHeightmapGeo = HeightmapGeometry::create();
beginEditCP(TutorialHeightmapGeo, HeightmapGeometry::HeightImageFieldMask | HeightmapGeometry::DimensionsFieldMask | HeightmapGeometry::SegmentsFieldMask | HeightmapGeometry::ScaleFieldMask | HeightmapGeometry::OffsetFieldMask | HeightmapGeometry::MaterialFieldMask);
TutorialHeightmapGeo->setHeightImage(PerlinNoiseImage);
TutorialHeightmapGeo->setDimensions(Vec2f(200.0,200.0));
TutorialHeightmapGeo->setSegments(Vec2f(150.0,150.0));
TutorialHeightmapGeo->setScale(30.0);
TutorialHeightmapGeo->setOffset(0.0);
TutorialHeightmapGeo->setMaterial( TheBlinnMat );
endEditCP(TutorialHeightmapGeo, HeightmapGeometry::HeightImageFieldMask | HeightmapGeometry::DimensionsFieldMask | HeightmapGeometry::SegmentsFieldMask | HeightmapGeometry::ScaleFieldMask | HeightmapGeometry::OffsetFieldMask | HeightmapGeometry::MaterialFieldMask);
calcVertexNormals(TutorialHeightmapGeo);
calcVertexTangents(TutorialHeightmapGeo,0,Geometry::TexCoords7FieldId, Geometry::TexCoords6FieldId);
//Make the Heightmap Node
NodePtr TutorialHeightmapNode = Node::create();
beginEditCP(TutorialHeightmapNode, Node::CoreFieldMask);
TutorialHeightmapNode->setCore(TutorialHeightmapGeo);
endEditCP (TutorialHeightmapNode, Node::CoreFieldMask);
//Make a SphereNode
GeometryPtr SphereGeo = makeSphereGeo(2,50.0);
//GeometryPtr SphereGeo = makeCylinderGeo(50,20.0, 16,true,true,true);
beginEditCP(SphereGeo, Geometry::MaterialFieldMask);
SphereGeo->setMaterial(TheLambertMat);
endEditCP (SphereGeo, Geometry::MaterialFieldMask);
calcVertexNormals(SphereGeo);
calcVertexTangents(SphereGeo,0,Geometry::TexCoords7FieldId, Geometry::TexCoords6FieldId);
NodePtr SphereNode = Node::create();
beginEditCP(SphereNode, Node::CoreFieldMask);
SphereNode->setCore(SphereGeo);
endEditCP (SphereNode, Node::CoreFieldMask);
//Make Main Scene Node
NodePtr scene = Node::create();
beginEditCP(scene, Node::CoreFieldMask | Node::ChildrenFieldMask);
scene->setCore(Group::create());
// add the torus as a child
scene->addChild(TutorialHeightmapNode);
//scene->addChild(SphereNode);
scene->addChild(ThePointLightBeaconNode);
endEditCP (scene, Node::CoreFieldMask | Node::ChildrenFieldMask);
//Add the scene to the Light Nodes
//beginEditCP(ThePointLightNode, Node::ChildrenFieldMask);
//ThePointLightNode->addChild(scene);
//endEditCP(ThePointLightNode, Node::ChildrenFieldMask);
//// tell the manager what to manage
//mgr->setRoot (ThePointLightNode);
beginEditCP(TheSpotLightNode, Node::ChildrenFieldMask);
TheSpotLightNode->addChild(scene);
endEditCP(TheSpotLightNode, Node::ChildrenFieldMask);
// tell the manager what to manage
mgr->setRoot (TheSpotLightNode);
mgr->turnHeadlightOff();
// show the whole scene
mgr->showAll();
//Open Window
Vec2f WinSize(TutorialWindowEventProducer->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindowEventProducer->getDesktopSize() - WinSize) *0.5);
TutorialWindowEventProducer->openWindow(WinPos,
WinSize,
"06Heightmap");
//Main Loop
TutorialWindowEventProducer->mainLoop();
osgExit();
return 0;
}