// Initialize GLUT & OpenSG and set up the scene int main(int argc, char **argv) { // OSG init osgInit(argc,argv); // GLUT init int winid = setupGLUT(&argc, argv); // the connection between GLUT and OpenSG GLUTWindowPtr gwin= GLUTWindow::create(); gwin->setId(winid); gwin->init(); lines.push_back(argc >= 2 ? argv[1] : "Hello World!"); lines.push_back("Powered by OpenSG"); lines.push_back("3rd line"); layoutParam.spacing = 1.5f; //layoutParam.length.push_back(10.f); //layoutParam.length.push_back(7.f); //layoutParam.length.push_back(-1.f); // put the geometry core into a node scene = Node::create(); GroupPtr groupPtr = Group::create(); beginEditCP(scene, Node::CoreFieldMask); { scene->setCore(groupPtr); } endEditCP(scene, Node::CoreFieldMask); // create the SimpleSceneManager helper mgr = new SimpleSceneManager; // tell the manager what to manage mgr->setWindow(gwin ); mgr->setRoot (scene); statfg = SimpleStatisticsForeground::create(); beginEditCP(statfg); statfg->setSize(25); statfg->setColor(Color4f(0,1,0,0.9)); statfg->addElement(familyDesc, "Family: %s"); statfg->addElement(styleDesc, "Style: %s"); statfg->addElement(majorAlignDesc, "Major Alignment: %s"); statfg->addElement(minorAlignDesc, "Minor Alignment: %s"); statfg->addElement(dirDesc, "%s"); statfg->addElement(horiDirDesc, "%s"); statfg->addElement(vertDirDesc, "%s"); endEditCP(statfg); // Create the background SolidBackgroundPtr bg = SolidBackground::create(); beginEditCP(bg); bg->setColor(Color3f(0.1, 0.1, 0.5)); endEditCP(bg); updateFace(); updateScene(); // add the statistics forground beginEditCP(gwin->getPort(0)); gwin->editPort(0)->editMFForegrounds()->push_back(statfg); gwin->editPort(0)->setBackground(bg); endEditCP(gwin->getPort(0)); // GLUT main loop glutMainLoop(); return 0; }
void ApplicationBuilder::attachApplication(void) { Inherited::attachApplication(); beginEditCP(ApplicationBuilderPtr(this) , ApplicationBuilder::EditingProjectFieldMask); setEditingProject(MainApplication::the()->getProject()); endEditCP(ApplicationBuilderPtr(this) , ApplicationBuilder::EditingProjectFieldMask); //Camera Beacon Matrix TransformMatrix; TransformPtr CameraBeaconTransform = Transform::create(); beginEditCP(CameraBeaconTransform, Transform::MatrixFieldMask); CameraBeaconTransform->setMatrix(TransformMatrix); endEditCP(CameraBeaconTransform, Transform::MatrixFieldMask); NodePtr CameraBeaconNode = Node::create(); beginEditCP(CameraBeaconNode, Node::CoreFieldMask); CameraBeaconNode->setCore(CameraBeaconTransform); endEditCP(CameraBeaconNode, Node::CoreFieldMask); // Make Main Scene Node empty NodePtr DefaultRootNode = osg::Node::create(); beginEditCP(DefaultRootNode, Node::CoreFieldMask | Node::ChildrenFieldMask); DefaultRootNode->setCore(osg::Group::create()); DefaultRootNode->addChild(CameraBeaconNode); endEditCP(DefaultRootNode, Node::CoreFieldMask | Node::ChildrenFieldMask); //Camera PerspectiveCameraPtr DefaultCamera = PerspectiveCamera::create(); beginEditCP(DefaultCamera); DefaultCamera->setBeacon(CameraBeaconNode); DefaultCamera->setFov (deg2rad(60.f)); DefaultCamera->setNear (0.1f); DefaultCamera->setFar (10000.f); endEditCP(DefaultCamera); //Background SolidBackgroundPtr DefaultBackground = SolidBackground::create(); beginEditCP(DefaultBackground, SolidBackground::ColorFieldMask); DefaultBackground->setColor(Color3f(0.0f,0.0f,0.0f)); endEditCP(DefaultBackground, SolidBackground::ColorFieldMask); //Icon Manager _IconManager = DefaultIconManager::create(); //User Interface ForegroundPtr UserInterfaceForeground = createInterface(); beginEditCP(_TheBuilderInterface->getDrawingSurface(), UIDrawingSurface::EventProducerFieldMask); _TheBuilderInterface->getDrawingSurface()->setEventProducer(MainApplication::the()->getMainWindowEventProducer()); endEditCP(_TheBuilderInterface->getDrawingSurface(), UIDrawingSurface::EventProducerFieldMask); //Viewport if(MainApplication::the()->getMainWindowEventProducer()->getWindow() != NullFC && MainApplication::the()->getMainWindowEventProducer()->getWindow()->getPort().size() == 0) { ViewportPtr DefaultViewport = Viewport::create(); beginEditCP(DefaultViewport); DefaultViewport->setCamera (DefaultCamera); DefaultViewport->setRoot (DefaultRootNode); DefaultViewport->setSize (0.0f,0.0f, 1.0f,1.0f); DefaultViewport->setBackground (DefaultBackground); DefaultViewport->getForegrounds().push_back (UserInterfaceForeground); endEditCP(DefaultViewport); beginEditCP(MainApplication::the()->getMainWindowEventProducer()->getWindow(), Window::PortFieldMask); MainApplication::the()->getMainWindowEventProducer()->getWindow()->addPort(DefaultViewport); endEditCP(MainApplication::the()->getMainWindowEventProducer()->getWindow(), Window::PortFieldMask); } }
virtual void initialize(void) { // Check necessary stuff if(_win == NullFC) { FWARNING(("SceneManager::initialize: window not set, " "ignoring!\n")); return; } // the rendering action _ownAction = RenderAction::create(); _action = _ownAction; // the camera and light beacon NodePtr cartN = Node::create(); _cart = Transform::create(); beginEditCP(cartN); cartN->setCore(_cart); endEditCP(cartN); // the headlight _internalRoot = Node::create(); _headlight = DirectionalLight::create(); addRefCP(_internalRoot); beginEditCP(_internalRoot); _internalRoot->setCore(_headlight); _internalRoot->addChild(cartN); endEditCP(_internalRoot); beginEditCP(_headlight); _headlight->setAmbient (.3, .3, .3, 1); _headlight->setDiffuse ( 1, 1, 1, 1); _headlight->setSpecular ( 1, 1, 1, 1); _headlight->setDirection( 0, 0, 1); _headlight->setBeacon (cartN); endEditCP(_headlight); // the camera _camera = PerspectiveCamera::create(); addRefCP(_camera); beginEditCP(PerspectiveCameraPtr::dcast(_camera)); PerspectiveCameraPtr::dcast(_camera)->setBeacon(cartN); PerspectiveCameraPtr::dcast(_camera)->setFov (deg2rad(60.f)); PerspectiveCameraPtr::dcast(_camera)->setNear (0.1f); PerspectiveCameraPtr::dcast(_camera)->setFar (10000.f); endEditCP(PerspectiveCameraPtr::dcast(_camera)); // need a viewport? if(_win->getPort().size() == 0) { SolidBackgroundPtr bg = SolidBackground::create(); beginEditCP(bg); bg->setColor(Color3f(0, 0, 0)); endEditCP(bg); ViewportPtr vp = Viewport::create(); beginEditCP(vp); vp->setCamera (_camera); vp->setRoot (_internalRoot); vp->setSize (0,0, 1,1); vp->setBackground (bg); endEditCP(vp); beginEditCP(_win); _win->addPort(vp); endEditCP(_win); } }
// Initialize GLUT & OpenSG and set up the scene int main(int argc, char **argv) { // OSG init osgInit(argc,argv); // GLUT init int winid = setupGLUT(&argc, argv); gwin = GLUTWindow::create(); // create root rootNode = makeCoredNode<Group>(); NodePtr scene = makeCoredNode<Group>(); // create lights TransformPtr point1_trans; NodePtr point1 = makeCoredNode<PointLight>(&_point1_core); NodePtr point1_beacon = makeCoredNode<Transform>(&point1_trans); beginEditCP(point1_trans); point1_trans->editMatrix().setTranslate(0.0, 0.0, 25.0); endEditCP(point1_trans); beginEditCP(_point1_core); _point1_core->setAmbient(0.15,0.15,0.15,1); _point1_core->setDiffuse(0.4,0.4,0.4,1); _point1_core->setSpecular(0.0,0.0,0.0,1); _point1_core->setBeacon(point1_beacon); _point1_core->setOn(true); endEditCP(_point1_core); TransformPtr point2_trans; NodePtr point2 = makeCoredNode<PointLight>(&_point2_core); NodePtr point2_beacon = makeCoredNode<Transform>(&point2_trans); beginEditCP(point2_trans); point2_trans->editMatrix().setTranslate(5.0, 5.0, 20.0); endEditCP(point2_trans); beginEditCP(_point2_core); _point2_core->setAmbient(0.15,0.15,0.15,1); _point2_core->setDiffuse(0.4,0.4,0.4,1); _point2_core->setSpecular(0.0,0.0,0.0,1); _point2_core->setBeacon(point2_beacon); _point2_core->setOn(true); endEditCP(_point2_core); beginEditCP(point1); point1->addChild(point2); endEditCP(point1); beginEditCP(point2); point2->addChild(scene); endEditCP(point2); // create scene // bottom NodePtr plane = makePlane(25.0, 25.0, 128, 128); int size = imageWinWidth*imageWinHeight*256; ImagePtr plane_img = Image::create(); beginEditCP(plane_img); plane_img->set(Image::OSG_RGBA_PF, imageWinWidth, imageWinHeight, 1, 1, 1, 0, NULL); endEditCP(plane_img); TextureChunkPtr plane_tex = TextureChunk::create(); beginEditCP(plane_tex); plane_tex->setImage(plane_img); plane_tex->setMinFilter(GL_LINEAR); plane_tex->setMagFilter(GL_LINEAR); plane_tex->setTarget(GL_TEXTURE_2D); plane_tex->setInternalFormat(GL_RGBA16F_ARB); endEditCP(plane_tex); SHLChunkPtr shl = SHLChunk::create(); beginEditCP(shl); shl->setVertexProgram(_vp_program); shl->setFragmentProgram(_fp_program); shl->setUniformParameter("tex0", 0); endEditCP(shl); SimpleMaterialPtr plane_mat = SimpleMaterial::create(); beginEditCP(plane_mat); plane_mat->setAmbient(Color3f(0.3,0.3,0.3)); plane_mat->setDiffuse(Color3f(1.0,1.0,1.0)); plane_mat->addChunk(plane_tex); plane_mat->addChunk(shl); endEditCP(plane_mat); GeometryPtr plane_geo = GeometryPtr::dcast(plane->getCore()); beginEditCP(plane_geo); plane_geo->setMaterial(plane_mat); beginEditCP(plane_geo); // box box_trans_node = makeCoredNode<Transform>(&_box_trans); beginEditCP(_box_trans); _box_trans->editMatrix().setTranslate(0.0, 0.0, 12.0); endEditCP(_box_trans); NodePtr box = makeBox(4.0, 4.0, 0.8, 10, 10 , 10); beginEditCP(box_trans_node); box_trans_node->addChild(box); endEditCP(box_trans_node); PolygonChunkPtr pchunk = osg::PolygonChunk::create(); beginEditCP(pchunk); pchunk->setCullFace(GL_BACK); endEditCP(pchunk); SimpleMaterialPtr box_mat = SimpleMaterial::create(); beginEditCP(box_mat); box_mat->setAmbient(Color3f(0.0,0.0,0.0)); box_mat->setDiffuse(Color3f(0.0,0.0,1.0)); box_mat->addChunk(pchunk); endEditCP(box_mat); GeometryPtr box_geo = GeometryPtr::dcast(box->getCore()); beginEditCP(box_geo); box_geo->setMaterial(box_mat); beginEditCP(box_geo); // cylinder1 NodePtr cylinder1_trans_node = makeCoredNode<Transform>(&_cylinder1_trans); beginEditCP(_cylinder1_trans); _cylinder1_trans->editMatrix().setTranslate(0.0, 0.0, 5.0); endEditCP(_cylinder1_trans); NodePtr cylinder1 = OSG::makeCylinder(10.0, 0.4, 32, true, true ,true); beginEditCP(cylinder1_trans_node); cylinder1_trans_node->addChild(cylinder1); endEditCP(cylinder1_trans_node); SimpleMaterialPtr cylinder1_mat = SimpleMaterial::create(); beginEditCP(cylinder1_mat); cylinder1_mat->setAmbient(Color3f(0.0,0.0,0.0)); cylinder1_mat->setDiffuse(Color3f(1.0,0.0,0.0)); cylinder1_mat->addChunk(pchunk); endEditCP(cylinder1_mat); GeometryPtr cylinder1_geo = GeometryPtr::dcast(cylinder1->getCore()); beginEditCP(cylinder1_geo); cylinder1_geo->setMaterial(cylinder1_mat); beginEditCP(cylinder1_geo); // cylinder2 NodePtr cylinder2_trans_node = makeCoredNode<Transform>(&_cylinder2_trans); beginEditCP(_cylinder2_trans); _cylinder2_trans->editMatrix().setTranslate(0.0, 0.0, 8.0); endEditCP(_cylinder2_trans); NodePtr cylinder2 = OSG::makeCylinder(10.0, 0.4, 32, true, true ,true); beginEditCP(cylinder2_trans_node); cylinder2_trans_node->addChild(cylinder2); endEditCP(cylinder2_trans_node); SimpleMaterialPtr cylinder2_mat = SimpleMaterial::create(); beginEditCP(cylinder2_mat); cylinder2_mat->setAmbient(Color3f(0.0,0.0,0.0)); cylinder2_mat->setDiffuse(Color3f(0.0,1.0,0.0)); cylinder2_mat->addChunk(pchunk); endEditCP(cylinder2_mat); GeometryPtr cylinder2_geo = GeometryPtr::dcast(cylinder2->getCore()); beginEditCP(cylinder2_geo); cylinder2_geo->setMaterial(cylinder2_mat); beginEditCP(cylinder2_geo); // scene beginEditCP(scene); scene->addChild(plane); scene->addChild(box_trans_node); scene->addChild(cylinder1_trans_node); scene->addChild(cylinder2_trans_node); endEditCP(scene); vp = ShadowViewport::create(); GradientBackgroundPtr gbg = GradientBackground::create(); SolidBackgroundPtr sbg = SolidBackground::create(); UChar8 imgdata[] = { 255,0,0, 0,255,0, 0,0,255, 255,255,0 }; ImagePtr img1 = Image::create(); img1->set(Image::OSG_RGB_PF, 2, 2, 1, 1, 1, 0, imgdata); TextureChunkPtr tcPtr = TextureChunk::create(); beginEditCP(tcPtr); tcPtr->setImage(img1); endEditCP(tcPtr); TextureBackgroundPtr bkg = TextureBackground::create(); beginEditCP(bkg); bkg->setTexture(tcPtr); endEditCP(bkg); beginEditCP(sbg); sbg->setColor(Color3f(0.2,0.4,0.6)); endEditCP(sbg); beginEditCP(gbg); gbg->addLine(Color3f(0.7, 0.7, 0.8), 0); gbg->addLine(Color3f(0.1, 0.1, 0.3), 1); endEditCP(gbg); beginEditCP(rootNode); rootNode->addChild(point1); rootNode->addChild(point1_beacon); rootNode->addChild(point2_beacon); endEditCP(rootNode); //FBOViewportPtr fbo_vp = FBOViewport::create(); addRefCP(fbo_vp); // the Camera for the map cam = PerspectiveCamera::create(); beginEditCP(cam); cam->setFov(osgdegree2rad(90)); cam->setAspect(1); cam->setNear(0.001); cam->setFar(10000); cam->setBeacon(box_trans_node); endEditCP(cam); beginEditCP(fbo_vp); fbo_vp->setBackground(bkg); fbo_vp->setRoot(rootNode); fbo_vp->setCamera(cam); fbo_vp->setSize(0,0,imageWinWidth-1, imageWinHeight-1); fbo_vp->setStorageWidth(imageWinWidth); fbo_vp->setStorageHeight(imageWinHeight); fbo_vp->setDirty(true); fbo_vp->editMFTextures ()->push_back(plane_tex); fbo_vp->editMFExcludeNodes()->push_back(plane); fbo_vp->setFboOn(true); endEditCP(fbo_vp); // normal shadow viewport beginEditCP(vp); vp->setBackground(gbg); vp->setRoot(rootNode); vp->setSize(0,0,1,1); endEditCP(vp); beginEditCP(gwin); //Window gwin->setId(winid); gwin->addPort(vp); gwin->init(); endEditCP(gwin); Vec3f min,max; rootNode->updateVolume(); rootNode->getVolume().getBounds( min, max ); // create the SimpleSceneManager helper mgr = new SimpleSceneManager; mgr->setWindow(gwin); mgr->setRoot(rootNode); //Viewport beginEditCP(vp); vp->setCamera(mgr->getCamera()); endEditCP(vp); mgr->turnHeadlightOff(); mgr->showAll(); // GLUT main loop glutMainLoop(); return 0; }
FBOViewportPtr createSceneFBO(void) { //Create Camera Beacon Matrix CameraMat; CameraMat.setTranslate(0.0f,0.0f,4.0f); TransformPtr CameraBeconCore = Transform::create(); beginEditCP(CameraBeconCore, Transform::MatrixFieldMask); CameraBeconCore->setMatrix(CameraMat); endEditCP(CameraBeconCore, Transform::MatrixFieldMask); NodePtr CameraBeconNode = Node::create(); beginEditCP(CameraBeconNode, Node::CoreFieldMask); CameraBeconNode->setCore(CameraBeconCore); endEditCP(CameraBeconNode, Node::CoreFieldMask); //Create Camera PerspectiveCameraPtr TheCamera = PerspectiveCamera::create(); beginEditCP(TheCamera); TheCamera->setFov(deg2rad(60.0f)); TheCamera->setAspect(1.0f); TheCamera->setNear(0.1f); TheCamera->setFar(100.0f); TheCamera->setBeacon(CameraBeconNode); endEditCP(TheCamera); //Make the Material BlinnMaterialPtr TheMaterial = BlinnMaterial::create(); beginEditCP(TheMaterial); TheMaterial->setDiffuse(0.8); TheMaterial->setColor(Color3f(1.0,1.0,1.0)); TheMaterial->setAmbientColor(Color3f(1.0,1.0,1.0)); TheMaterial->setNumLights(1); endEditCP(TheMaterial); // Make Torus Node (creates Torus in background of scene) NodePtr TorusGeometryNode = makeTorus(.5, 2, 24, 48); beginEditCP(TorusGeometryNode->getCore()); GeometryPtr::dcast(TorusGeometryNode->getCore())->setMaterial(TheMaterial); endEditCP(TorusGeometryNode->getCore()); calcVertexNormals(GeometryPtr::dcast(TorusGeometryNode->getCore())); calcVertexTangents(GeometryPtr::dcast(TorusGeometryNode->getCore()),0,Geometry::TexCoords7FieldId, Geometry::TexCoords6FieldId); RootTransformCore = Transform::create(); NodePtr TorusTransformNode = Node::create(); beginEditCP(TorusTransformNode, Node::CoreFieldMask); TorusTransformNode->setCore(RootTransformCore); TorusTransformNode->addChild(TorusGeometryNode); endEditCP(TorusTransformNode, Node::CoreFieldMask); //Create Light Beacon Matrix LightMat; LightMat.setTranslate(0.0f,10.0f,1.0f); TransformPtr LightBeconCore = Transform::create(); beginEditCP(LightBeconCore, Transform::MatrixFieldMask); LightBeconCore->setMatrix(LightMat); endEditCP(LightBeconCore, Transform::MatrixFieldMask); NodePtr LightBeconNode = Node::create(); beginEditCP(LightBeconNode, Node::CoreFieldMask); LightBeconNode->setCore(LightBeconCore); endEditCP(LightBeconNode, Node::CoreFieldMask); //Create Light TheLight = PointLight::create(); beginEditCP(TheLight); TheLight->setBeacon(LightBeconNode); endEditCP(TheLight); NodePtr LightNode = Node::create(); beginEditCP(LightNode, Node::CoreFieldMask); LightNode->setCore(TheLight); LightNode->addChild(TorusTransformNode); endEditCP(LightNode, Node::CoreFieldMask); //Create Root NodePtr TheRoot = Node::create(); beginEditCP(TheRoot); TheRoot->setCore(Group::create()); TheRoot->addChild(CameraBeconNode); TheRoot->addChild(LightNode); TheRoot->addChild(LightBeconNode); endEditCP(TheRoot); //Create Background SolidBackgroundPtr TheBackground = SolidBackground::create(); TheBackground->setColor(Color3f(1.0,0.0,0.0)); //DepthClearBackgroundPtr TheBackground = DepthClearBackground::create(); //Create the Image ImagePtr TheColorImage = Image::create(); TheColorImage->set(Image::OSG_RGB_PF,2,2,1,1,1,0.0f,0,Image::OSG_FLOAT16_IMAGEDATA); //Create the texture TextureChunkPtr TheColorTextureChunk = TextureChunk::create(); beginEditCP(TheColorTextureChunk); TheColorTextureChunk->setImage(TheColorImage); TheColorTextureChunk->setMinFilter(GL_NEAREST); TheColorTextureChunk->setMagFilter(GL_NEAREST); TheColorTextureChunk->setWrapS(GL_CLAMP_TO_EDGE); TheColorTextureChunk->setWrapR(GL_CLAMP_TO_EDGE); TheColorTextureChunk->setScale(false); TheColorTextureChunk->setNPOTMatrixScale(true); TheColorTextureChunk->setEnvMode(GL_REPLACE); TheColorTextureChunk->setInternalFormat(GL_RGB16F); endEditCP(TheColorTextureChunk); //Create FBO FBOViewportPtr TheFBO = FBOViewport::create(); beginEditCP(TheFBO); TheFBO->setBackground(TheBackground); TheFBO->setRoot(TheRoot); TheFBO->setCamera(TheCamera); TheFBO->setEnabled(true); TheFBO->getTextures().push_back(TheColorTextureChunk); TheFBO->setStorageWidth(TheColorTextureChunk->getImage()->getWidth()); TheFBO->setStorageHeight(TheColorTextureChunk->getImage()->getHeight()); TheFBO->setSize(0,0,TheColorTextureChunk->getImage()->getWidth()-1, TheColorTextureChunk->getImage()->getHeight()-1); endEditCP(TheFBO); return TheFBO; }
int main (int argc, char **argv) { osgInit(argc,argv); // GLUT init glutInit(&argc, argv); glutInitDisplayMode( GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE); int winid = glutCreateWindow("OpenSG"); glutKeyboardFunc(key); glutVisibilityFunc(vis); glutReshapeFunc(reshape); glutDisplayFunc(display); glutMouseFunc(mouse); glutMotionFunc(motion); glutIdleFunc(display); // glPolygonMode( GL_FRONT_AND_BACK, GL_LINE ); glEnable( GL_DEPTH_TEST ); glEnable( GL_LIGHTING ); glEnable( GL_LIGHT0 ); // OSG SceneFileHandler::the().print(); // create the graph // beacon for camera and light NodePtr b1n = Node::create(); GroupPtr b1 = Group::create(); beginEditCP(b1n); b1n->setCore( b1 ); endEditCP(b1n); // transformation NodePtr t1n = Node::create(); TransformPtr t1 = Transform::create(); beginEditCP(t1n); t1n->setCore( t1 ); t1n->addChild( b1n ); endEditCP(t1n); cam_trans = t1; // light NodePtr dlight = Node::create(); DirectionalLightPtr dl = DirectionalLight::create(); beginEditCP(dlight); dlight->setCore( dl ); endEditCP(dlight); beginEditCP(dl); dl->setAmbient( .3, .3, .3, 1 ); dl->setDiffuse( 1, 1, 1, 1 ); dl->setDirection(0,0,1); dl->setBeacon( b1n); endEditCP(dl); // root root = Node::create(); GroupPtr gr1 = Group::create(); beginEditCP(root); root->setCore( gr1 ); root->addChild( t1n ); root->addChild( dlight ); endEditCP(root); // Load the file NodePtr file = NullFC; NodePtr file1 = NullFC; if ( argc > 1 ) file1 = SceneFileHandler::the().read(argv[1]); if ( file1 == NullFC ) { std::cerr << "Couldn't load file, ignoring" << std::endl; file1 = makeTorus( .5, 2, 16, 16 ); } file1->updateVolume(); // file->dump(); // subRefCP(file); // return 0; Vec3f min,max; file1->getVolume().getBounds( min, max ); std::cout << "Volume: from " << min << " to " << max << std::endl; file = Node::create(); MaterialGroupPtr testMat = MaterialGroup::create(); SimpleMaterialPtr defaultMaterial = SimpleMaterial::create(); beginEditCP(defaultMaterial); defaultMaterial->setDiffuse(Color3f(1,.0,.0)); defaultMaterial->setAmbient(Color3f(0.1,0.1,0.1)); defaultMaterial->setSpecular(Color3f(1,1,1)); defaultMaterial->setShininess(20); endEditCP (defaultMaterial); testMat->setMaterial(defaultMaterial); beginEditCP(file); { // file->setCore(testMat); file->setCore(Group::create()); file->addChild(file1); } endEditCP (file); scene_trans = Transform::create(); NodePtr sceneTrN = Node::create(); beginEditCP(sceneTrN); { sceneTrN->setCore(scene_trans); sceneTrN->addChild(file); sceneTrN->addChild(makeTorus( .5, 2, 16, 16 )); } endEditCP(sceneTrN); beginEditCP(dlight); dlight->addChild(sceneTrN); endEditCP(dlight); std::cerr << "Tree: " << std::endl; // root->dump(); // Camera cam = PerspectiveCamera::create(); cam->setBeacon( b1n ); cam->setFov( deg2rad( 90 ) ); cam->setNear( 0.1 ); cam->setFar( 100000 ); // Background SolidBackgroundPtr bkgnd = SolidBackground::create(); beginEditCP(bkgnd, SolidBackground::ColorFieldMask); bkgnd->setColor(Color3f(1,1,1)); endEditCP(bkgnd, SolidBackground::ColorFieldMask); // Viewport vp = Viewport::create(); vp->setCamera( cam ); vp->setBackground( bkgnd ); vp->setRoot( root ); vp->setSize( 0,0, 1,1 ); // Window std::cout << "GLUT winid: " << winid << std::endl; GLUTWindowPtr gwin; GLint glvp[4]; glGetIntegerv( GL_VIEWPORT, glvp ); gwin = GLUTWindow::create(); gwin->setId(winid); gwin->setSize( glvp[2], glvp[3] ); win = gwin; win->addPort( vp ); win->init(); // Action ract = DrawAction::create(); renact = RenderAction::create(); // tball Vec3f pos; pos.setValues(min[0] + ((max[0] - min[0]) * 0.5), min[1] + ((max[1] - min[1]) * 0.5), max[2] + ( max[2] - min[2] ) * 1.5 ); float scale = (max[2] - min[2] + max[1] - min[1] + max[0] - min[0]) / 6; Pnt3f tCenter(min[0] + (max[0] - min[0]) / 2, min[1] + (max[1] - min[1]) / 2, min[2] + (max[2] - min[2]) / 2); tball.setMode( Trackball::OSGObject ); tball.setStartPosition( pos, true ); tball.setSum( true ); tball.setTranslationMode( Trackball::OSGFree ); tball.setTranslationScale(scale); tball.setRotationCenter(tCenter); // run... glutMainLoop(); return 0; }
int main(int argc, char **argv) { printf("Press the keys '1', '2' and '3' in order to switch between " "the different example objects.\n"); printf("Press key 'f' to toggle FatBorder rendering.\n"); osgInit(argc,argv); // GLUT init glutInit(&argc, argv); glutInitWindowSize(800,600); glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE); int winid = glutCreateWindow("OpenSG"); glutReshapeFunc(reshape); glutDisplayFunc(display); glutIdleFunc(display); glutMouseFunc(mouse); glutMotionFunc(motion); glutKeyboardFunc(keyboard); GLUTWindowPtr gwin = GLUTWindow::create(); beginEditCP(gwin); { gwin->setId(winid); } endEditCP(gwin); gwin->init(); // create the scene // NodePtr scene; g_scene = makeScene( ); setModel(0); // scene = makeTeapot( ); if ( g_scene == NullFC ) { std::cerr<<"makeScene returned NullFC, exiting..."<<std::endl; return -1; } // create the SimpleSceneManager helper g_mgr = new SimpleSceneManager; // create the window and initial camera/viewport g_mgr->setWindow( gwin ); // tell the manager what to manage g_mgr->setRoot ( g_scene ); // show the whole scene g_mgr->showAll(); g_mgr->redraw(); SolidBackgroundPtr bgr = SolidBackground::create(); beginEditCP( bgr ); bgr->setColor( Color3f( 1.0, 1.0, 1.0 )); endEditCP( bgr ); g_mgr->getWindow()->getPort(0)->setBackground( bgr ); // GLUT main loop glutMainLoop(); return 0; }
// Initialize GLUT & OpenSG and set up the scene int main(int argc, char **argv) { // OSG init osgInit(argc,argv); // GLUT init int winid = setupGLUT(&argc, argv); // the connection between GLUT and OpenSG GLUTWindowPtr gwin= GLUTWindow::create(); gwin->setId(winid); gwin->init(); // put the geometry core into a node scene = Node::create(); GroupPtr groupPtr = Group::create(); beginEditCP(scene, Node::CoreFieldMask); { scene->setCore(groupPtr); } endEditCP(scene, Node::CoreFieldMask); // create the SimpleSceneManager helper mgr = new SimpleSceneManager; // tell the manager what to manage mgr->setWindow(gwin ); mgr->setRoot (scene); //mgr->getAction()->setFrustumCulling(false); // Create the background SolidBackgroundPtr bg = SolidBackground::create(); beginEditCP(bg); bg->setColor(Color3f(0.1, 0.1, 0.5)); endEditCP(bg); face = getStatisticsDefaultFont(); TextureChunkPtr texChunk = getStatisticsDefaultFontTexture(); MaterialChunkPtr matChunk = MaterialChunk::create(); beginEditCP(matChunk); { matChunk->setAmbient(Color4f(1.f, 1.f, 1.f, 1.f)); matChunk->setDiffuse(Color4f(1.f, 1.f, 1.f, 1.f)); matChunk->setEmission(Color4f(0.f, 0.f, 0.f, 1.f)); matChunk->setSpecular(Color4f(0.f, 0.f, 0.f, 1.f)); matChunk->setShininess(0); } endEditCP(matChunk); BlendChunkPtr blendChunk = BlendChunk::create(); beginEditCP(blendChunk, BlendChunk::DestFactorFieldMask); { blendChunk->setSrcFactor(GL_SRC_ALPHA); blendChunk->setDestFactor(GL_ONE_MINUS_SRC_ALPHA); } endEditCP(blendChunk, BlendChunk::DestFactorFieldMask); textMaterial = ChunkMaterial::create(); beginEditCP(textMaterial); { textMaterial->addChunk(texChunk); textMaterial->addChunk(matChunk); textMaterial->addChunk(blendChunk); } endEditCP(textMaterial); updateScene(); beginEditCP(gwin->getPort(0)); gwin->getPort(0)->setBackground(bg); endEditCP(gwin->getPort(0)); // GLUT main loop glutMainLoop(); return 0; }