// 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;
}
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);
TutorialUpdateListener TheTutorialUpdateListener;
TutorialWindowEventProducer->addUpdateListener(&TheTutorialUpdateListener);
//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(MainWindow);
//Print key command info
std::cout << "\n\nKEY COMMANDS:" << std::endl;
std::cout << "space Play/Pause the animation" << std::endl;
std::cout << "G Show/Hide the grid" << std::endl;
std::cout << "A Show/Hide the axes" << std::endl;
std::cout << "B Show/Hide the bind pose skeleton" << std::endl;
std::cout << "SHIFT-B Show/Hide the bind pose mesh" << std::endl;
std::cout << "P Show/Hide the current pose skeleton" << std::endl;
std::cout << "SHIFT-P Show/Hide the current pose mesh" << std::endl;
std::cout << "CTRL-Q Exit\n\n" << std::endl;
//Setup axes
LineChunkPtr AxesLineChunk = LineChunk::create();
beginEditCP(AxesLineChunk);
AxesLineChunk->setWidth(0.0f);
AxesLineChunk->setSmooth(true);
endEditCP(AxesLineChunk);
//Axes material
ChunkMaterialPtr AxesMaterial = ChunkMaterial::create();
beginEditCP(AxesMaterial, ChunkMaterial::ChunksFieldMask);
AxesMaterial->addChunk(AxesLineChunk);
endEditCP(AxesMaterial, ChunkMaterial::ChunksFieldMask);
//Grid material
ChunkMaterialPtr gridMaterial = ChunkMaterial::create();
beginEditCP(gridMaterial, ChunkMaterial::ChunksFieldMask);
gridMaterial->addChunk(AxesLineChunk);
endEditCP(gridMaterial, ChunkMaterial::ChunksFieldMask);
//Axes should render as lines
GeoPTypesPtr axesType = GeoPTypesUI8::create();
beginEditCP(axesType, GeoPTypesUI8::GeoPropDataFieldMask);
{
axesType->addValue(GL_LINES);
}
endEditCP (axesType, GeoPTypesUI8::GeoPropDataFieldMask);
//Grid type
GeoPTypesPtr gridType = GeoPTypesUI8::create();
beginEditCP(gridType, GeoPTypesUI8::GeoPropDataFieldMask);
{
gridType->addValue(GL_LINES);
}
endEditCP (gridType, GeoPTypesUI8::GeoPropDataFieldMask);
//Axes lens
GeoPLengthsPtr axesLens = GeoPLengthsUI32::create();
beginEditCP(axesLens, GeoPLengthsUI32::GeoPropDataFieldMask);
{
axesLens->addValue(6);
}
endEditCP (axesLens, GeoPLengthsUI32::GeoPropDataFieldMask);
//Grid lens
GeoPLengthsPtr gridLens = GeoPLengthsUI32::create();
beginEditCP(gridLens, GeoPLengthsUI32::GeoPropDataFieldMask);
{
gridLens->addValue(84);
}
endEditCP (gridLens, GeoPLengthsUI32::GeoPropDataFieldMask);
//Axes points
GeoPositions3fPtr axesPnts = GeoPositions3f::create();
beginEditCP(axesPnts, GeoPositions3f::GeoPropDataFieldMask);
{
// X-Axis
axesPnts->addValue(Pnt3f(0, 0, 0));
axesPnts->addValue(Pnt3f(15, 0, 0));
// Y-Axis
axesPnts->addValue(Pnt3f(0, 0, 0));
axesPnts->addValue(Pnt3f(0, 15, 0));
// Z-Axis
axesPnts->addValue(Pnt3f(0, 0, 0));
axesPnts->addValue(Pnt3f(0, 0, 15));
}
endEditCP (axesPnts, GeoPositions3f::GeoPropDataFieldMask);
//Grid points
GeoPositions3fPtr gridPnts = GeoPositions3f::create();
beginEditCP(gridPnts, GeoPositions3f::GeoPropDataFieldMask);
{
float height = 0;
gridPnts->addValue(Pnt3f(-10, height, 0));
if(height == 0)
gridPnts->addValue(Pnt3f(0, height, 0));
else
gridPnts->addValue(Pnt3f(10, height, 0));
gridPnts->addValue(Pnt3f(-10, height, 1));
gridPnts->addValue(Pnt3f(10, height, 1));
gridPnts->addValue(Pnt3f(-10, height, 2));
gridPnts->addValue(Pnt3f(10, height, 2));
gridPnts->addValue(Pnt3f(-10, height, 3));
gridPnts->addValue(Pnt3f(10, height, 3));
gridPnts->addValue(Pnt3f(-10, height, 4));
gridPnts->addValue(Pnt3f(10, height, 4));
gridPnts->addValue(Pnt3f(-10, height, 5));
gridPnts->addValue(Pnt3f(10, height, 5));
gridPnts->addValue(Pnt3f(-10, height, 6));
gridPnts->addValue(Pnt3f(10, height, 6));
gridPnts->addValue(Pnt3f(-10, height, 7));
gridPnts->addValue(Pnt3f(10, height, 7));
gridPnts->addValue(Pnt3f(-10, height, 8));
gridPnts->addValue(Pnt3f(10, height, 8));
gridPnts->addValue(Pnt3f(-10, height, 9));
gridPnts->addValue(Pnt3f(10, height, 9));
gridPnts->addValue(Pnt3f(-10, height, 10));
gridPnts->addValue(Pnt3f(10, height, 10));
gridPnts->addValue(Pnt3f(-10, height, -1));
gridPnts->addValue(Pnt3f(10, height, -1));
gridPnts->addValue(Pnt3f(-10, height, -2));
gridPnts->addValue(Pnt3f(10, height, -2));
gridPnts->addValue(Pnt3f(-10, height, -3));
gridPnts->addValue(Pnt3f(10, height, -3));
gridPnts->addValue(Pnt3f(-10, height, -4));
gridPnts->addValue(Pnt3f(10, height, -4));
gridPnts->addValue(Pnt3f(-10, height, -5));
gridPnts->addValue(Pnt3f(10, height, -5));
gridPnts->addValue(Pnt3f(-10, height, -6));
gridPnts->addValue(Pnt3f(10, height, -6));
gridPnts->addValue(Pnt3f(-10, height, -7));
gridPnts->addValue(Pnt3f(10, height, -7));
gridPnts->addValue(Pnt3f(-10, height, -8));
gridPnts->addValue(Pnt3f(10, height, -8));
gridPnts->addValue(Pnt3f(-10, height, -9));
gridPnts->addValue(Pnt3f(10, height, -9));
gridPnts->addValue(Pnt3f(-10, height, -10));
gridPnts->addValue(Pnt3f(10, height, -10));
gridPnts->addValue(Pnt3f(0, height, -10));
if(height == 0)
gridPnts->addValue(Pnt3f(0, height, 0));
else
gridPnts->addValue(Pnt3f(0, height, 10));
gridPnts->addValue(Pnt3f(1, height, -10));
gridPnts->addValue(Pnt3f(1, height, 10));
gridPnts->addValue(Pnt3f(2, height, -10));
gridPnts->addValue(Pnt3f(2, height, 10));
gridPnts->addValue(Pnt3f(3, height, -10));
gridPnts->addValue(Pnt3f(3, height, 10));
gridPnts->addValue(Pnt3f(4, height, -10));
gridPnts->addValue(Pnt3f(4, height, 10));
gridPnts->addValue(Pnt3f(5, height, -10));
gridPnts->addValue(Pnt3f(5, height, 10));
gridPnts->addValue(Pnt3f(6, height, -10));
gridPnts->addValue(Pnt3f(6, height, 10));
gridPnts->addValue(Pnt3f(7, height, -10));
gridPnts->addValue(Pnt3f(7, height, 10));
gridPnts->addValue(Pnt3f(8, height, -10));
gridPnts->addValue(Pnt3f(8, height, 10));
gridPnts->addValue(Pnt3f(9, height, -10));
gridPnts->addValue(Pnt3f(9, height, 10));
gridPnts->addValue(Pnt3f(10, height, -10));
gridPnts->addValue(Pnt3f(10, height, 10));
gridPnts->addValue(Pnt3f(-1, height, -10));
gridPnts->addValue(Pnt3f(-1, height, 10));
gridPnts->addValue(Pnt3f(-2, height, -10));
gridPnts->addValue(Pnt3f(-2, height, 10));
gridPnts->addValue(Pnt3f(-3, height, -10));
gridPnts->addValue(Pnt3f(-3, height, 10));
gridPnts->addValue(Pnt3f(-4, height, -10));
gridPnts->addValue(Pnt3f(-4, height, 10));
gridPnts->addValue(Pnt3f(-5, height, -10));
gridPnts->addValue(Pnt3f(-5, height, 10));
gridPnts->addValue(Pnt3f(-6, height, -10));
gridPnts->addValue(Pnt3f(-6, height, 10));
gridPnts->addValue(Pnt3f(-7, height, -10));
gridPnts->addValue(Pnt3f(-7, height, 10));
gridPnts->addValue(Pnt3f(-8, height, -10));
gridPnts->addValue(Pnt3f(-8, height, 10));
gridPnts->addValue(Pnt3f(-9, height, -10));
gridPnts->addValue(Pnt3f(-9, height, 10));
gridPnts->addValue(Pnt3f(-10, height, -10));
gridPnts->addValue(Pnt3f(-10, height, 10));
}
endEditCP (gridPnts, GeoPositions3f::GeoPropDataFieldMask);
//Axes normals
GeoNormals3fPtr axesNorms = GeoNormals3f::create();
beginEditCP(axesNorms, GeoNormals3f::GeoPropDataFieldMask);
axesNorms->addValue(Vec3f( 0.0,0.0,1.0));
axesNorms->addValue(Vec3f( 0.0,0.0,1.0));
axesNorms->addValue(Vec3f( 0.0,0.0,1.0));
axesNorms->addValue(Vec3f( 0.0,0.0,1.0));
axesNorms->addValue(Vec3f( 1.0,0.0,0.0));
axesNorms->addValue(Vec3f( 1.0,0.0,0.0));
endEditCP(axesNorms, GeoNormals3f::GeoPropDataFieldMask);
//Grid normals
GeoNormals3fPtr gridNorms = GeoNormals3f::create();
beginEditCP(gridNorms, GeoNormals3f::GeoPropDataFieldMask);
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
gridNorms->addValue(Vec3f( 0.0,0.0,1.0));
endEditCP(gridNorms, GeoNormals3f::GeoPropDataFieldMask);
//Axes colors
GeoColors3fPtr axesColors = GeoColors3f::create();
beginEditCP(axesColors, GeoColors3f::GeoPropDataFieldMask);
//X-Axis = Red
axesColors->addValue(Color3f( 1.0,0.0,0.0));
axesColors->addValue(Color3f( 1.0,0.0,0.0));
//Y-Axis = Green
axesColors->addValue(Color3f( 0.0,1.0,0.0));
axesColors->addValue(Color3f( 0.0,1.0,0.0));
//Z-Axis = Blue
axesColors->addValue(Color3f( 0.0,0.0,1.0));
axesColors->addValue(Color3f( 0.0,0.0,1.0));
endEditCP(axesColors, GeoColors3f::GeoPropDataFieldMask);
//Grid gridColors
GeoColors3fPtr gridColors = GeoColors3f::create();
beginEditCP(gridColors, GeoColors3f::GeoPropDataFieldMask);
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
gridColors->addValue(Color3f( 0.5,0.5,0.5));
endEditCP(gridColors, GeoColors3f::GeoPropDataFieldMask);
//Create axes geometry
GeometryPtr axesGeo = Geometry::create();
beginEditCP(axesGeo, Geometry::TypesFieldMask |
Geometry::LengthsFieldMask |
Geometry::PositionsFieldMask |
Geometry::NormalsFieldMask |
Geometry::MaterialFieldMask |
Geometry::ColorsFieldMask);
{
axesGeo->setTypes (axesType);
axesGeo->setLengths (axesLens);
axesGeo->setPositions(axesPnts);
axesGeo->setNormals(axesNorms);
axesGeo->setColors(axesColors);
// assign a material to the geometry to make it visible. The details
// of materials are defined later.
axesGeo->setMaterial(AxesMaterial);
}
endEditCP (axesGeo, Geometry::TypesFieldMask |
Geometry::LengthsFieldMask |
Geometry::PositionsFieldMask |
Geometry::NormalsFieldMask |
Geometry::MaterialFieldMask |
Geometry::ColorsFieldMask );
//Create grid geometry
GeometryPtr gridGeo = Geometry::create();
beginEditCP(gridGeo, Geometry::TypesFieldMask |
Geometry::LengthsFieldMask |
Geometry::PositionsFieldMask |
Geometry::NormalsFieldMask |
Geometry::MaterialFieldMask |
Geometry::ColorsFieldMask);
{
gridGeo->setTypes (gridType);
gridGeo->setLengths (gridLens);
gridGeo->setPositions(gridPnts);
gridGeo->setNormals(gridNorms);
gridGeo->setColors(gridColors);
// assign a material to the geometry to make it visible. The details
// of materials are defined later.
gridGeo->setMaterial(AxesMaterial);
}
endEditCP (gridGeo, Geometry::TypesFieldMask |
Geometry::LengthsFieldMask |
Geometry::PositionsFieldMask |
Geometry::NormalsFieldMask |
Geometry::MaterialFieldMask |
Geometry::ColorsFieldMask );
//Create unbound geometry Node
Axes = osg::Node::create();
beginEditCP(Axes, Node::CoreFieldMask);
Axes->setCore(axesGeo);
endEditCP(Axes, Node::CoreFieldMask);
//Create unbound geometry Node
Grid = osg::Node::create();
beginEditCP(Grid, Node::CoreFieldMask);
Grid->setCore(gridGeo);
endEditCP(Grid, Node::CoreFieldMask);
//Import scene from an XML file
ChunkMaterialPtr ExampleMaterial;
std::vector<SkeletonPtr> SkeletonPtrs;
std::vector<SkeletonBlendedGeometryPtr> SkeletonBlendedGeometryPtrs;
std::vector<GeometryPtr> GeometryPtrs;
FCFileType::FCPtrStore NewContainers;
NewContainers = FCFileHandler::the()->read(Path("./Data/21SceneFromMaya.xml"));
FCFileType::FCPtrStore::iterator Itor;
for(Itor = NewContainers.begin() ; Itor != NewContainers.end() ; ++Itor)
{
if( (*Itor)->getType() == (ChunkMaterial::getClassType()))
{
//Set ExampleMaterial to the ChunkMaterial we just read in
ExampleMaterial = (ChunkMaterial::Ptr::dcast(*Itor));
}
if( (*Itor)->getType() == (Skeleton::getClassType()))
{
//Add the skeleton we just read in to SkeletonPtrs
SkeletonPtrs.push_back(Skeleton::Ptr::dcast(*Itor));
}
if( (*Itor)->getType() == (SkeletonBlendedGeometry::getClassType()))
{
//Add the SkeletonBlendedGeometry we just read in to SkeletonBlendedGeometryPtrs
SkeletonBlendedGeometryPtrs.push_back(SkeletonBlendedGeometry::Ptr::dcast(*Itor));
}
if( (*Itor)->getType().isDerivedFrom(SkeletonAnimation::getClassType()))
{
//Set TheSkeletonAnimation to the Animation we just read in
TheSkeletonAnimation = (Animation::Ptr::dcast(*Itor));
}
if( (*Itor)->getType() == (Geometry::getClassType()))
{
//Add the Geometry we just read in to GeometryPtrs
GeometryPtrs.push_back(Geometry::Ptr::dcast(*Itor));
}
}
//Create unbound geometry Node (to show the mesh in its bind pose)
for (int i(0); i < GeometryPtrs.size(); ++i)
{
NodePtr UnboundGeometry = Node::create();
beginEditCP(UnboundGeometry, Node::CoreFieldMask | Node::TravMaskFieldMask);
UnboundGeometry->setCore(GeometryPtrs[i]);
UnboundGeometry->setTravMask(0);
endEditCP(UnboundGeometry, Node::CoreFieldMask | Node::TravMaskFieldMask);
UnboundGeometries.push_back(UnboundGeometry);
}
//Create skeleton nodes
for (int i(0); i < SkeletonPtrs.size(); ++i)
{
//SkeletonDrawer
SkeletonDrawablePtr ExampleSkeletonDrawable = osg::SkeletonDrawable::create();
beginEditCP(ExampleSkeletonDrawable, SkeletonDrawable::SkeletonFieldMask | SkeletonDrawable::MaterialFieldMask | SkeletonDrawable::DrawPoseFieldMask | SkeletonDrawable::PoseColorFieldMask | SkeletonDrawable::DrawBindPoseFieldMask | SkeletonDrawable::BindPoseColorFieldMask);
ExampleSkeletonDrawable->setSkeleton(SkeletonPtrs[i]);
ExampleSkeletonDrawable->setMaterial(AxesMaterial);
ExampleSkeletonDrawable->setDrawPose(true); //By default we draw the current skeleton
ExampleSkeletonDrawable->setPoseColor(Color4f(1.0, 0.0, 1.0, 1.0)); //Set color of current skeleton
ExampleSkeletonDrawable->setDrawBindPose(false); //By default we don't draw the bind pose skeleton
ExampleSkeletonDrawable->setBindPoseColor(Color4f(1.0, 1.0, 0.0, 1.0)); //Set color of bind pose skeleton
endEditCP(ExampleSkeletonDrawable, SkeletonDrawable::SkeletonFieldMask | SkeletonDrawable::MaterialFieldMask | SkeletonDrawable::DrawPoseFieldMask | SkeletonDrawable::PoseColorFieldMask | SkeletonDrawable::DrawBindPoseFieldMask | SkeletonDrawable::BindPoseColorFieldMask);
//Skeleton Node
NodePtr SkeletonNode = osg::Node::create();
beginEditCP(SkeletonNode, Node::CoreFieldMask);
SkeletonNode->setCore(ExampleSkeletonDrawable);
endEditCP(SkeletonNode, Node::CoreFieldMask);
SkeletonNodes.push_back(SkeletonNode);
}
//Create skeleton blended geometry nodes
for (int i(0); i < SkeletonBlendedGeometryPtrs.size(); ++i)
{
NodePtr MeshNode = osg::Node::create();
beginEditCP(MeshNode, Node::CoreFieldMask);
MeshNode->setCore(SkeletonBlendedGeometryPtrs[i]);
endEditCP(MeshNode, Node::CoreFieldMask);
MeshNodes.push_back(MeshNode);
}
//Create Animation Advancer
TheAnimationAdvancer = osg::ElapsedTimeAnimationAdvancer::create();
osg::beginEditCP(TheAnimationAdvancer);
osg::ElapsedTimeAnimationAdvancer::Ptr::dcast(TheAnimationAdvancer)->setStartTime( 0.0 );
osg::beginEditCP(TheAnimationAdvancer);
//Add nodes to scene
NodePtr scene = osg::Node::create();
beginEditCP(scene, Node::CoreFieldMask | Node::ChildrenFieldMask);
scene->setCore(osg::Group::create());
scene->addChild(Axes);
scene->addChild(Grid);
//Add all imported skeletons to scene
for (int i(0); i < SkeletonNodes.size(); ++i)
{
scene->addChild(SkeletonNodes[i]);
}
//Add all imported geometries to scene
for (int i(0); i < UnboundGeometries.size(); ++i)
{
scene->addChild(UnboundGeometries[i]);
}
//Add all imported SkeletonBlendedGeometries to scene
for (int i(0); i < MeshNodes.size(); ++i)
{
scene->addChild(MeshNodes[i]);
}
endEditCP(scene, Node::CoreFieldMask | Node::ChildrenFieldMask);
mgr->setRoot(scene);
//By default the animation is not paused
animationPaused = false;
// Show the whole Scene
mgr->showAll();
TheAnimationAdvancer->start();
//Show window
Vec2f WinSize(TutorialWindowEventProducer->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindowEventProducer->getDesktopSize() - WinSize) *0.5);
TutorialWindowEventProducer->openWindow(WinPos,
WinSize,
"21LoadXMLSceneFromMaya");
//Enter main Loop
TutorialWindowEventProducer->mainLoop();
osgExit();
return 0;
}
// Initialize 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(MainWindow);
//Print key command info
std::cout << "\n\nKEY COMMANDS:" << std::endl;
std::cout << "space Play/Pause the animation" << std::endl;
std::cout << "B Show/Hide the bind pose skeleton" << std::endl;
std::cout << "SHIFT-B Show/Hide the bind pose mesh" << std::endl;
std::cout << "P Show/Hide the current pose skeleton" << std::endl;
std::cout << "SHIFT-P Show/Hide the current pose mesh" << std::endl;
std::cout << "O Toggle override status of TheSecondAnimation" << std::endl;
std::cout << "CTRL-Q Exit\n\n" << std::endl;
//Import scene from XML
ChunkMaterialPtr ExampleMaterial;
std::vector<SkeletonPtr> SkeletonPtrs;
std::vector<SkeletonBlendedGeometryPtr> SkeletonBlendedGeometryPtrs;
std::vector<GeometryPtr> GeometryPtrs;
//Skeleton materaial
LineChunkPtr SkelLineChunk = LineChunk::create();
beginEditCP(SkelLineChunk);
SkelLineChunk->setWidth(0.0f);
SkelLineChunk->setSmooth(true);
endEditCP(SkelLineChunk);
ChunkMaterialPtr SkelMaterial = ChunkMaterial::create();
beginEditCP(SkelMaterial, ChunkMaterial::ChunksFieldMask);
SkelMaterial->addChunk(SkelLineChunk);
endEditCP(SkelMaterial, ChunkMaterial::ChunksFieldMask);
//LOAD FIRST ANIMATION
FCFileType::FCPtrStore NewContainers;
NewContainers = FCFileHandler::the()->read(BoostPath("./Data/23WalkingAnimation.xml"));
FCFileType::FCPtrStore::iterator Itor;
for(Itor = NewContainers.begin() ; Itor != NewContainers.end() ; ++Itor)
{
if( (*Itor)->getType() == (ChunkMaterial::getClassType()))
{
//Set ExampleMaterial to the ChunkMaterial we just read in
ExampleMaterial = (ChunkMaterial::Ptr::dcast(*Itor));
}
if( (*Itor)->getType() == (Skeleton::getClassType()))
{
//Add the Skeleton we just read in to SkeletonPtrs
SkeletonPtrs.push_back(Skeleton::Ptr::dcast(*Itor));
}
if( (*Itor)->getType() == (SkeletonBlendedGeometry::getClassType()))
{
//Add the SkeletonBlendedGeometry we just read in to SkeletonBlendedGeometryPtrs
SkeletonBlendedGeometryPtrs.push_back(SkeletonBlendedGeometry::Ptr::dcast(*Itor));
}
if( (*Itor)->getType().isDerivedFrom(SkeletonAnimation::getClassType()))
{
//Set TheWalkingAnimation to the SkeletonAnimation we just read in
TheWalkingAnimation = (SkeletonAnimation::Ptr::dcast(*Itor));
}
if( (*Itor)->getType() == (Geometry::getClassType()))
{
//Add the Geometry we just read in to GeometryPtrs
GeometryPtrs.push_back(Geometry::Ptr::dcast(*Itor));
}
}
//LOAD SECOND ANIMATION
NewContainers = FCFileHandler::the()->read(BoostPath("./Data/23SamAnimation.xml"));
for(Itor = NewContainers.begin() ; Itor != NewContainers.end() ; ++Itor)
{
//Import only the skeletonAnimation from the second XML file; we've already imported the skeleton and the geometry
if( (*Itor)->getType().isDerivedFrom(SkeletonAnimation::getClassType()))
{
TheSecondAnimation = (SkeletonAnimation::Ptr::dcast(*Itor));
}
}
//Blend the two animations
TheSkeletonBlendedAnimation = SkeletonBlendedAnimation::create();
beginEditCP(TheSkeletonBlendedAnimation);
TheSkeletonBlendedAnimation->addAnimationBlending(TheWalkingAnimation, BlendWalking, false);
TheSkeletonBlendedAnimation->addAnimationBlending(TheSecondAnimation, BlendTouchScreen, false);
endEditCP(TheSkeletonBlendedAnimation);
//Create unbound geometry Node (to show the mesh in its bind pose)
for (int i(0); i < GeometryPtrs.size(); ++i)
{
NodePtr UnboundGeometry = Node::create();
beginEditCP(UnboundGeometry, Node::CoreFieldMask | Node::TravMaskFieldMask);
UnboundGeometry->setCore(GeometryPtrs[i]);
UnboundGeometry->setTravMask(0); //By default, we don't show the mesh in its bind pose.
endEditCP(UnboundGeometry, Node::CoreFieldMask | Node::TravMaskFieldMask);
UnboundGeometries.push_back(UnboundGeometry);
}
//Create skeleton nodes
for (int i(0); i < SkeletonPtrs.size(); ++i)
{
//SkeletonDrawer
SkeletonDrawablePtr ExampleSkeletonDrawable = osg::SkeletonDrawable::create();
beginEditCP(ExampleSkeletonDrawable, SkeletonDrawable::SkeletonFieldMask | SkeletonDrawable::MaterialFieldMask | SkeletonDrawable::DrawPoseFieldMask | SkeletonDrawable::PoseColorFieldMask | SkeletonDrawable::DrawBindPoseFieldMask | SkeletonDrawable::BindPoseColorFieldMask);
ExampleSkeletonDrawable->setSkeleton(SkeletonPtrs[i]);
ExampleSkeletonDrawable->setMaterial(SkelMaterial);
ExampleSkeletonDrawable->setDrawPose(true); //By default we draw the current skeleton
ExampleSkeletonDrawable->setPoseColor(Color4f(1.0, 0.0, 1.0, 1.0)); //Set color of current skeleton
ExampleSkeletonDrawable->setDrawBindPose(false); //By default we don't draw the bind pose skeleton
ExampleSkeletonDrawable->setBindPoseColor(Color4f(1.0, 1.0, 0.0, 1.0)); //Set color of bind pose skeleton
endEditCP(ExampleSkeletonDrawable, SkeletonDrawable::SkeletonFieldMask | SkeletonDrawable::MaterialFieldMask | SkeletonDrawable::DrawPoseFieldMask | SkeletonDrawable::PoseColorFieldMask | SkeletonDrawable::DrawBindPoseFieldMask | SkeletonDrawable::BindPoseColorFieldMask);
//Skeleton Node
NodePtr SkeletonNode = osg::Node::create();
beginEditCP(SkeletonNode, Node::CoreFieldMask);
SkeletonNode->setCore(ExampleSkeletonDrawable);
endEditCP(SkeletonNode, Node::CoreFieldMask);
SkeletonNodes.push_back(SkeletonNode);
}
//Create skeleton blended geometry nodes
for (int i(0); i < SkeletonBlendedGeometryPtrs.size(); ++i)
{
NodePtr MeshNode = osg::Node::create();
beginEditCP(MeshNode, Node::CoreFieldMask);
MeshNode->setCore(SkeletonBlendedGeometryPtrs[i]);
endEditCP(MeshNode, Node::CoreFieldMask);
MeshNodes.push_back(MeshNode);
}
//Setup scene
NodePtr EmptyScene = osg::Node::create();
beginEditCP(EmptyScene, Node::CoreFieldMask);
EmptyScene->setCore(Group::create());
endEditCP (EmptyScene, Node::CoreFieldMask);
mgr->setRoot(EmptyScene);
//User Interface
// Create the Graphics
GraphicsPtr TutorialGraphics = osg::Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
// Create the DefaultBoundedRangeModelPtr and
// set its values
DefaultBoundedRangeModelPtr UpperAnimationSliderRangeModel = DefaultBoundedRangeModel::create();
UpperAnimationSliderRangeModel->setMinimum(0);
UpperAnimationSliderRangeModel->setMaximum(100);
UpperAnimationSliderRangeModel->setValue(BlendWalking * 100);
UpperAnimationSliderRangeModel->setExtent(0);
//Create the upper animation blend amount slider
LabelPtr TempLabel;
SliderPtr UpperAnimationSlider = Slider::create();
beginEditCP(UpperAnimationSlider, Slider::LabelMapFieldMask | Slider::PreferredSizeFieldMask | Slider::MajorTickSpacingFieldMask | Slider::MinorTickSpacingFieldMask | Slider::SnapToTicksFieldMask | Slider::DrawLabelsFieldMask | Slider::RangeModelFieldMask);
//Label the slider
TempLabel = Label::Ptr::dcast(UpperAnimationSlider->getLabelPrototype()->shallowCopy());
beginEditCP(TempLabel, Label::TextFieldMask); TempLabel->setText("0.0"); endEditCP(TempLabel, Label::TextFieldMask);
UpperAnimationSlider->getLabelMap()[0] = TempLabel;
TempLabel = Label::Ptr::dcast(UpperAnimationSlider->getLabelPrototype()->shallowCopy());
beginEditCP(TempLabel, Label::TextFieldMask); TempLabel->setText("1.0"); endEditCP(TempLabel, Label::TextFieldMask);
UpperAnimationSlider->getLabelMap()[100] = TempLabel;
//Customize the slider
UpperAnimationSlider->setPreferredSize(Vec2f(100, 300));
UpperAnimationSlider->setSnapToTicks(false);
UpperAnimationSlider->setMajorTickSpacing(10);
UpperAnimationSlider->setMinorTickSpacing(5);
UpperAnimationSlider->setOrientation(Slider::VERTICAL_ORIENTATION);
UpperAnimationSlider->setInverted(true);
UpperAnimationSlider->setDrawLabels(true);
UpperAnimationSlider->setRangeModel(UpperAnimationSliderRangeModel);
endEditCP(UpperAnimationSlider, Slider::LabelMapFieldMask | Slider::PreferredSizeFieldMask | Slider::MajorTickSpacingFieldMask | Slider::MinorTickSpacingFieldMask | Slider::SnapToTicksFieldMask | Slider::DrawLabelsFieldMask | Slider::RangeModelFieldMask);
DefaultBoundedRangeModelPtr LowerAnimationSliderRangeModel = DefaultBoundedRangeModel::create();
LowerAnimationSliderRangeModel->setMinimum(0);
LowerAnimationSliderRangeModel->setMaximum(100);
LowerAnimationSliderRangeModel->setValue(BlendTouchScreen * 100);
LowerAnimationSliderRangeModel->setExtent(0);
//Create the lower animation blend amount slider
SliderPtr LowerAnimationSlider = Slider::create();
beginEditCP(LowerAnimationSlider, Slider::LabelMapFieldMask | Slider::PreferredSizeFieldMask | Slider::MajorTickSpacingFieldMask | Slider::MinorTickSpacingFieldMask | Slider::SnapToTicksFieldMask | Slider::DrawLabelsFieldMask | Slider::RangeModelFieldMask);
//Label the slider
TempLabel = Label::Ptr::dcast(LowerAnimationSlider->getLabelPrototype()->shallowCopy());
beginEditCP(TempLabel, Label::TextFieldMask); TempLabel->setText("0.0"); endEditCP(TempLabel, Label::TextFieldMask);
LowerAnimationSlider->getLabelMap()[0] = TempLabel;
TempLabel = Label::Ptr::dcast(LowerAnimationSlider->getLabelPrototype()->shallowCopy());
beginEditCP(TempLabel, Label::TextFieldMask); TempLabel->setText("1.0"); endEditCP(TempLabel, Label::TextFieldMask);
LowerAnimationSlider->getLabelMap()[100] = TempLabel;
//Customize the slider
LowerAnimationSlider->setPreferredSize(Vec2f(100, 300));
LowerAnimationSlider->setSnapToTicks(false);
LowerAnimationSlider->setMajorTickSpacing(10);
LowerAnimationSlider->setMinorTickSpacing(5);
LowerAnimationSlider->setOrientation(Slider::VERTICAL_ORIENTATION);
LowerAnimationSlider->setInverted(true);
LowerAnimationSlider->setDrawLabels(true);
LowerAnimationSlider->setRangeModel(LowerAnimationSliderRangeModel);
endEditCP(LowerAnimationSlider, Slider::LabelMapFieldMask | Slider::PreferredSizeFieldMask | Slider::MajorTickSpacingFieldMask | Slider::MinorTickSpacingFieldMask | Slider::SnapToTicksFieldMask | Slider::DrawLabelsFieldMask | Slider::RangeModelFieldMask);
// Create Background to be used with the MainFrame
ColorLayerPtr MainFrameBackground = osg::ColorLayer::create();
beginEditCP(MainFrameBackground, ColorLayer::ColorFieldMask);
MainFrameBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
endEditCP(MainFrameBackground, ColorLayer::ColorFieldMask);
// Create The Main InternalWindow
// 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);
LayoutPtr MainInternalWindowLayout = osg::FlowLayout::create();
//GL Viewport
ComponentPtr TheGLViewport = createGLPanel();
InternalWindowPtr MainInternalWindow = osg::InternalWindow::create();
beginEditCP(MainInternalWindow, InternalWindow::ChildrenFieldMask | InternalWindow::LayoutFieldMask | InternalWindow::BackgroundsFieldMask | InternalWindow::AlignmentInDrawingSurfaceFieldMask | InternalWindow::ScalingInDrawingSurfaceFieldMask | InternalWindow::DrawTitlebarFieldMask | InternalWindow::ResizableFieldMask);
MainInternalWindow->getChildren().push_back(UpperAnimationSlider);
MainInternalWindow->getChildren().push_back(LowerAnimationSlider);
MainInternalWindow->getChildren().push_back(TheGLViewport);
MainInternalWindow->setLayout(MainInternalWindowLayout);
MainInternalWindow->setBackgrounds(MainInternalWindowBackground);
MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setScalingInDrawingSurface(Vec2f(1.0f,1.0f));
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);
ViewportPtr TutorialViewport = mgr->getWindow()->getPort(0);
beginEditCP(TutorialViewport, Viewport::ForegroundsFieldMask);
TutorialViewport->getForegrounds().push_back(TutorialUIForeground);
beginEditCP(TutorialViewport, Viewport::ForegroundsFieldMask);
//Attach the Slider Listeners
BlendAmountSliderChangeListener UpperAnimationSliderListener(TheSkeletonBlendedAnimation, 0, UpperAnimationSlider);
UpperAnimationSlider->addChangeListener(&UpperAnimationSliderListener);
BlendAmountSliderChangeListener LowerAnimationSliderListener(TheSkeletonBlendedAnimation, 1, LowerAnimationSlider);
LowerAnimationSlider->addChangeListener(&LowerAnimationSliderListener);
//Animation Advancer
TheAnimationAdvancer = ElapsedTimeAnimationAdvancer::create();
beginEditCP(TheAnimationAdvancer);
ElapsedTimeAnimationAdvancer::Ptr::dcast(TheAnimationAdvancer)->setStartTime( 0.0 );
beginEditCP(TheAnimationAdvancer);
//Create the Documentation
SimpleScreenDoc TheSimpleScreenDoc(&sceneManager, TutorialWindow);
// Show the whole Scene
mgr->showAll();
TheAnimationAdvancer->start();
//Show window
Vec2f WinSize(TutorialWindowEventProducer->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindowEventProducer->getDesktopSize() - WinSize) *0.5);
TutorialWindowEventProducer->openWindow(WinPos,
WinSize,
"23BlendXMLAnimations");
//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;
}
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);
TutorialUpdateListener TheTutorialUpdateListener;
TutorialWindowEventProducer->addUpdateListener(&TheTutorialUpdateListener);
//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(MainWindow);
//Print key command info
std::cout << "\n\nKEY COMMANDS:" << std::endl;
std::cout << "space Play/Pause the animation" << std::endl;
std::cout << "B Show/Hide the bind pose skeleton" << std::endl;
std::cout << "SHIFT-B Show/Hide the bind pose mesh" << std::endl;
std::cout << "P Show/Hide the current pose skeleton" << std::endl;
std::cout << "SHIFT-P Show/Hide the current pose mesh" << std::endl;
std::cout << "CTRL-Q Exit\n\n" << std::endl;
//Import scene from XML
ChunkMaterialPtr ExampleMaterial;
SkeletonPtr ExampleSkeleton;
SkeletonBlendedGeometryPtr TheNewSkeletonGeometry;
GeometryPtr ExampleGeometry;
FCFileType::FCPtrStore NewContainers;
NewContainers = FCFileHandler::the()->read(Path("./Data/20BlendedGeometry.xml"));
FCFileType::FCPtrStore::iterator Itor;
for(Itor = NewContainers.begin() ; Itor != NewContainers.end() ; ++Itor)
{
if( (*Itor)->getType() == (ChunkMaterial::getClassType()))
{
//Set ExampleMaterial to the ChunkMaterial we just read in
ExampleMaterial = (ChunkMaterial::Ptr::dcast(*Itor));
}
if( (*Itor)->getType() == (Skeleton::getClassType()))
{
//Set ExampleSkeleton to the Skeleton we just read in
ExampleSkeleton = (Skeleton::Ptr::dcast(*Itor));
}
if( (*Itor)->getType() == (Geometry::getClassType()))
{
//Set ExampleGeometry to the geometry we just read in
ExampleGeometry = (Geometry::Ptr::dcast(*Itor));
}
if( (*Itor)->getType() == (SkeletonBlendedGeometry::getClassType()))
{
//Set TheNewSkeletonGeometry to the SkeletonBlendedGeometry we just read in
TheNewSkeletonGeometry = (SkeletonBlendedGeometry::Ptr::dcast(*Itor));
}
if( (*Itor)->getType().isDerivedFrom(Animation::getClassType()))
{
//Set TheSkeletonAnimation to the Animation we just read in
TheSkeletonAnimation = (Animation::Ptr::dcast(*Itor));
}
}
//UnboundGeometry
UnboundGeometry = Node::create();
beginEditCP(UnboundGeometry, Node::CoreFieldMask | Node::TravMaskFieldMask);
UnboundGeometry->setCore(ExampleGeometry);
UnboundGeometry->setTravMask(0);
endEditCP(UnboundGeometry, Node::CoreFieldMask | Node::TravMaskFieldMask);
//SkeletonDrawer
SkeletonDrawablePtr ExampleSkeletonDrawable = osg::SkeletonDrawable::create();
beginEditCP(ExampleSkeletonDrawable, SkeletonDrawable::SkeletonFieldMask | SkeletonDrawable::MaterialFieldMask | SkeletonDrawable::DrawBindPoseFieldMask | SkeletonDrawable::BindPoseColorFieldMask | SkeletonDrawable::DrawPoseFieldMask | SkeletonDrawable::PoseColorFieldMask);
ExampleSkeletonDrawable->setSkeleton(ExampleSkeleton);
ExampleSkeletonDrawable->setMaterial(ExampleMaterial);
ExampleSkeletonDrawable->setDrawBindPose(false); //By default, we don't draw the skeleton's bind pose
ExampleSkeletonDrawable->setBindPoseColor(Color4f(0.0, 1.0, 0.0, 1.0)); //When drawn, the skeleton's bind pose renders in green
ExampleSkeletonDrawable->setDrawPose(true); //By default, we do draw the skeleton's current pose
ExampleSkeletonDrawable->setPoseColor(Color4f(0.0, 0.0, 1.0, 1.0)); //The skeleton's current pose renders in blue
endEditCP(ExampleSkeletonDrawable, SkeletonDrawable::SkeletonFieldMask | SkeletonDrawable::MaterialFieldMask | SkeletonDrawable::DrawBindPoseFieldMask | SkeletonDrawable::BindPoseColorFieldMask | SkeletonDrawable::DrawPoseFieldMask | SkeletonDrawable::PoseColorFieldMask);
//Skeleton Node
SkeletonNode = osg::Node::create();
beginEditCP(SkeletonNode, Node::CoreFieldMask);
SkeletonNode->setCore(ExampleSkeletonDrawable);
endEditCP(SkeletonNode, Node::CoreFieldMask);
//Skeleton Blended Geometry Node
MeshNode = osg::Node::create();
beginEditCP(MeshNode, Node::CoreFieldMask);
MeshNode->setCore(TheNewSkeletonGeometry);
endEditCP(MeshNode, Node::CoreFieldMask);
//Animation Advancer
TheAnimationAdvancer = osg::ElapsedTimeAnimationAdvancer::create();
osg::beginEditCP(TheAnimationAdvancer);
osg::ElapsedTimeAnimationAdvancer::Ptr::dcast(TheAnimationAdvancer)->setStartTime( 0.0 );
osg::beginEditCP(TheAnimationAdvancer);
//Create scene
NodePtr scene = osg::Node::create();
beginEditCP(scene, Node::CoreFieldMask | Node::ChildrenFieldMask);
scene->setCore(osg::Group::create());
scene->addChild(UnboundGeometry);
scene->addChild(SkeletonNode);
scene->addChild(MeshNode);
endEditCP(scene, Node::CoreFieldMask | Node::ChildrenFieldMask);
mgr->setRoot(scene);
// Show the whole Scene
mgr->showAll();
TheAnimationAdvancer->start();
//Show window
Vec2f WinSize(TutorialWindowEventProducer->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindowEventProducer->getDesktopSize() - WinSize) *0.5);
TutorialWindowEventProducer->openWindow(WinPos,
WinSize,
"20LoadXMLBlendedGeometry");
//Enter 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);
// 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;
}