Hello
> it possible that either your hardware or (more likely) your drivers
do not support framebuffer objects ?
nope GL_EXTENSION_STRING: GL_EXT_framebuffer_object
I also tryed it on an other PC with gf8
> What happens if you replace the fbo_vp->setFboOn(true) line with
> fbo_vp->setFboOn(false) ? (This fakes the FBO behavior by rendering
to the framebuffer and copying the
> data around).
ok the demo 29 render nothnig ... the winows stays empty
the other code from you render but the PNG is empty
> You can also take a look at OpenSG/Tutorials/29FBOTexture.cpp (the
attached version has basically your
> changes from above included) which is a simpler example using the
FBOViewport and see if that gives you
> better results.
nope empty PNG,
for info I ave OpenSG 1.8.0? is This a problem?
eik
Carsten Neumann schrieb:
> Hello Eik,
>
> Eik Deistung wrote:
>> Hello
>>
>> i do not get it working ....
>> for testing I tryed just to write a Image to file.
>>
>> ok a least a used your Version from the mail to Abdalla from 15.02.
>> (code atached)
>>
>> I added in
>> main(int argc, char **argv)
>> -> fbo_vp->setReadBuffer(true); // added
>>
>> and in
>>
>> void keyboard(unsigned char k, int x, int y)
>>
>> case 'a':
>> {
>> fbo_vp-> getTextures(0)->getImage()->write("test1.png");
>> break;
>> }
>>
>> but only get black images.
>
> is it possible that either your hardware or (more likely) your drivers
> do not support framebuffer objects ?
> What happens if you replace the fbo_vp->setFboOn(true) line with
> fbo_vp->setFboOn(false) ? (This fakes the FBO behavior by rendering to
> the framebuffer and copying the data around).
>
> You can also take a look at OpenSG/Tutorials/29FBOTexture.cpp (the
> attached version has basically your changes from above included) which
> is a simpler example using the FBOViewport and see if that gives you
> better results.
>
> Hope it helps,
> Carsten
> ------------------------------------------------------------------------
>
> // OpenSG FBO example: 29FBOTexture.cpp
> //
> // Shows how to use the FBOViewport for render-to-texture
> //
>
> #include <OpenSG/OSGGLUT.h>
> #include <OpenSG/OSGConfig.h>
> #include <OpenSG/OSGSimpleSceneManager.h>
> #include <OpenSG/OSGGLUTWindow.h>
> #include <OpenSG/OSGGradientBackground.h>
> #include <OpenSG/OSGSceneFileHandler.h>
> #include <OpenSG/OSGSimpleGeometry.h>
> #include <OpenSG/OSGImage.h>
> #include <OpenSG/OSGTextureChunk.h>
> #include <OpenSG/OSGFBOViewport.h>
> #include <OpenSG/OSGSimpleTexturedMaterial.h>
> #include <OpenSG/OSGMatrixUtility.h>
> #include <OpenSG/OSGPointLight.h>
> #include <OpenSG/OSGQuaternion.h>
> #include <OpenSG/OSGGeoFunctions.h>
> #include <OpenSG/OSGImageFunctions.h>
> #include <OpenSG/OSGTwoSidedLightingChunk.h>
> #include <OpenSG/OSGComponentTransform.h>
> #include <OpenSG/OSGImageFileType.h>
> #include <OpenSG/OSGTextureTransformChunk.h>
>
> OSG_USING_NAMESPACE
>
> // globals
> SimpleSceneManager *mgr (NULL);
> FBOViewportPtr fboVP (NullFC);
> TransformPtr fboSceneTrans(NullFC);
> NodePtr fboCamBeacon (NullFC);
> GeometryPtr flagGeo (NullFC);
>
> // flag parameters
> const float flagHeight = 8.0f;
> const float flagWidth = 16.0f;
> const int flagGeoHor = (int)flagWidth * 3;
> const int flagGeoVert = (int)flagHeight / 2;
> const float flagWaveDamp = 0.06f;
>
> const float poleHeight = 24.0f;
> const float poleDia = poleHeight * 0.01f;
>
> // fbo size
> const int fboWidth = (int)flagWidth * 32;
> const int fboHeight = (int)flagHeight * 32;
>
> // forward declarations
> Matrix showAll(NodePtr root, PerspectiveCameraPtr cam);
>
> void animateFlag (Real64 t);
> void spinFBOScene(Real64 t);
>
> SimpleTexturedMaterialPtr createWoodMaterial();
> NodePtr buildFlag(TextureChunkPtr fboTexture, const int &flagHor, const int
> &flagVert);
> NodePtr buildFBOScene(int argc, char **argv );
> void setupFBO(TextureChunkPtr fboTexture, GLUTWindowPtr gwin, NodePtr
> fboScene );
>
> // redraw the window
> void display(void)
> {
> static Real64 t0 = OSG::getSystemTime();
>
> // get the current time
> Real64 t = OSG::getSystemTime() - t0;
>
> // animate flag
> animateFlag(t);
>
> // spin the fbo scene
> spinFBOScene(t);
>
> // get the RenderAction from SimpleSceneManager
> RenderAction *rAct = static_cast<RenderAction*>(::mgr->getAction());
>
> // render fbo scene
> ::fboVP->render(rAct);
>
> // render main scene
> ::mgr->redraw();
> }
>
> // react to size changes
> void reshape(int w, int h)
> {
> ::mgr->resize(w,h);
> glutPostRedisplay();
> }
>
> // react to mouse button presses
> void mouse(int button, int state, int x, int y)
> {
> if (state)
> ::mgr->mouseButtonRelease(button, x, y);
> else
> ::mgr->mouseButtonPress(button, x, y);
>
> glutPostRedisplay();
> }
>
> // react to mouse motions with pressed buttons
> void motion(int x, int y)
> {
> ::mgr->mouseMove(x, y);
> glutPostRedisplay();
> }
>
> // react to keys
> void keyboard(unsigned char k, int, int)
> {
> switch(k)
> {
> case 27: exit(1);
> case 'a': ::fboVP->getTextures(0)->getImage()->write("test1.png");
> break;
> default: break;
> }
> }
>
>
> int main(int argc, char **argv)
> {
> // OpenSG init
> osgInit(argc,argv);
>
> // GLUT init
> glutInit(&argc, argv);
> glutInitWindowSize(800,600);
> glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
>
> int winid = glutCreateWindow("OpenSG " OSG_VERSION_STRING " FBO example");
>
> // register GLUT callbacks
> glutReshapeFunc(reshape);
> glutDisplayFunc(display);
> glutIdleFunc(display);
> glutMouseFunc(mouse);
> glutMotionFunc(motion);
> glutKeyboardFunc(keyboard);
>
>
> // create a GLUTWindow
> GLUTWindowPtr gwin = GLUTWindow::create();
> beginEditCP(gwin);
> gwin->setId(winid);
> gwin->init();
> endEditCP(gwin);
>
> // create the SimpleSceneManager helper
> ::mgr = new SimpleSceneManager;
>
> // create the texture that is used as render target by the sub-scene
> // and as texture in the main scene
> TextureChunkPtr fboTexture = TextureChunk::create();
> beginEditCP(fboTexture);
> fboTexture->setEnvMode(GL_MODULATE);
> endEditCP(fboTexture);
>
> // create the main scene
> NodePtr mainScene = buildFlag(fboTexture, ::flagGeoHor, ::flagGeoVert);
>
> // create the fbo scene
> NodePtr fboScene = buildFBOScene(argc, argv);
>
> // create and setup the FBO
> setupFBO(fboTexture, gwin, fboScene);
>
> // create the window and initial camera/viewport
> ::mgr->setWindow(gwin);
>
> // tell the manager what to manage
> ::mgr->setRoot(mainScene);
>
> // show the whole scene
> ::mgr->showAll();
>
> // set a nicer background
> GradientBackgroundPtr bkg = GradientBackground::create();
> beginEditCP(bkg);
> bkg->addLine(Color3f(0.7, 0.7, 0.8), 0);
> bkg->addLine(Color3f(0.0, 0.1, 0.3), 1);
> endEditCP(bkg);
> gwin->getPort(0)->setBackground(bkg);
>
> // enable logo
> mgr->useOpenSGLogo();
>
> // make sure the window is setup before rendering to the FBO
> mgr->redraw();
>
> // enter the GLUT main loop
> glutMainLoop();
>
> return 0;
> }
>
> // copied from SimpleSceneManager
> Matrix showAll(NodePtr root, PerspectiveCameraPtr cam)
> {
> root->updateVolume();
>
> Vec3f min,max;
> root->getVolume().getBounds( min, max );
> Vec3f d = max - min;
>
> if(d.length() < Eps) // Nothing loaded? Use a unity box
> {
> min.setValues(-1.f,-1.f,-1.f);
> max.setValues( 1.f, 1.f, 1.f);
> d = max - min;
> }
>
> Real32 dist = osgMax(d[0],d[1]) / (2 * osgtan(cam->getFov() / 2.f));
>
> Vec3f up(0,1,0);
> Pnt3f at((min[0] + max[0]) * .5f,(min[1] + max[1]) * .5f,(min[2] +
> max[2]) * .5f);
> Pnt3f from = at;
> from[2]+=(dist+fabs(max[2]-min[2])*0.5f);
>
> // set the camera to go from 1% of the object to twice its size
> Real32 diag = osgMax(osgMax(d[0], d[1]), d[2]);
> beginEditCP(cam);
> cam->setFar (10 * diag);
> endEditCP(cam);
>
> Matrix m;
> MatrixLookAt(m, from, at, up);
>
> return m;
> }
>
> void animateFlag( Real64 t )
> {
> // get positions
> GeoPositions3fPtr pos =
> GeoPositions3fPtr::dcast(::flagGeo->getPositions());
> beginEditCP(pos, GeoPositions3f::GeoPropDataFieldMask);
> Pnt3f offset(-0.5f * flagWidth, 3, 0);
> float t2 = 8.0f * t;
> for(UInt32 i = 0; i < pos->getSize(); ++i)
> {
> Pnt3f p = pos->getValue(i);
> float v = p.dist(offset);
> // the flag geometry is centered at the origin
> // we need to offset the wave calculations
> float x = p[0] - offset.x();
> // make a wave, dampened towards the poleS
> p[2] = x * flagWaveDamp * osgsin(v-t2);
> pos->setValue(p, i);
> }
> endEditCP(pos, GeoPositions3f::GeoPropDataFieldMask);
>
> // correct normals
> calcVertexNormals(::flagGeo);
> }
>
> void spinFBOScene( Real64 t )
> {
> beginEditCP(::fboSceneTrans, Transform::MatrixFieldMask);
> Matrix m;
> Quaternion q;
> q.setValueAsAxisDeg(0, 1, 0, t * 16.66f);
> m.setRotate(q);
> ::fboSceneTrans->setMatrix(m);
> endEditCP(::fboSceneTrans, Transform::MatrixFieldMask);
> }
>
>
> // create a wood texture
> SimpleTexturedMaterialPtr createWoodMaterial()
> {
> SimpleTexturedMaterialPtr mat = SimpleTexturedMaterial::create();
> beginEditCP(mat);
> ImagePtr img = Image::create();
> createNoise(img, Image::OSG_L_PF, 7, 64);
> mat->setImage(img);
> mat->setEnvMode(GL_MODULATE);
> mat->setDiffuse(Color3f(0.9f, 0.57f, 0.1f));
> mat->setSpecular(Color3f(0.2f, 0.2f, 0.1f));
> TextureTransformChunkPtr ttrans = TextureTransformChunk::create();
> beginEditCP(ttrans);
> Matrix m;
> m.setScale(2.0, 8.0, 2.0);
> ttrans->setMatrix(m);
> endEditCP(ttrans);
> mat->addChunk(ttrans);
> endEditCP(mat);
>
> return mat;
> }
>
> NodePtr buildFlag(TextureChunkPtr fboTexture, const int &flagHor, const int
> &flagVert)
> {
> NodePtr flagScene = makeCoredNode<Group>();
>
> ::flagGeo = makePlaneGeo(flagWidth, flagHeight, flagHor, flagVert);
>
> // disable caching as we will change this geometry every frame
> beginEditCP(::flagGeo);
> ::flagGeo->setVbo(false);
> ::flagGeo->setDlistCache(false);
> endEditCP(::flagGeo);
>
> SimpleMaterialPtr fboMaterial = SimpleMaterial::create();
> beginEditCP(fboMaterial);
> fboMaterial->addChunk(fboTexture);
>
> // add a light glossy effect (environment noise-map)
> {
> ImagePtr noise = Image::create();
> createNoise(noise, Image::OSG_I_PF, 5, 256);
> beginEditCP(noise);
> // make noise image darker (as it will be GL_ADDed)
> for(int i = 0; i < noise->getSize(); ++i)
> noise->getData()[i] >>= 2; // *= 0.125
> endEditCP(noise);
> TextureChunkPtr gloss = TextureChunk::create();
> beginEditCP(gloss);
> gloss->setImage(noise);
> gloss->setEnvMode(GL_ADD);
> endEditCP(gloss);
> TexGenChunkPtr envMap = TexGenChunk::create();
> beginEditCP(envMap);
> envMap->setGenFuncS(GL_SPHERE_MAP);
> envMap->setGenFuncT(GL_SPHERE_MAP);
> endEditCP(envMap);
> // add for use with 2nd texture unit
> fboMaterial->addChunk(gloss, 1);
> fboMaterial->addChunk(envMap, 1);
> }
>
> fboMaterial->addChunk(TwoSidedLightingChunk::create());
> fboMaterial->setSpecular(Color3f(0.7f, 0.7f, 0.7f));
> fboMaterial->setDiffuse(Color3f(0.22f, 0.2f, 0.2f));
> endEditCP(fboMaterial);
>
>
> beginEditCP(::flagGeo);
> ::flagGeo->setMaterial(fboMaterial);
> endEditCP(::flagGeo);
>
> // create transform node to hook up the flag to the pole
> ComponentTransformPtr flagTrans;
> NodePtr flag = makeCoredNode<ComponentTransform>(&flagTrans);
> beginEditCP(flagTrans);
> Vec3f v(0.5f * flagWidth, 0.5f * (poleHeight - flagHeight) , 0.0f);
> flagTrans->setTranslation(v);
> endEditCP(flagTrans);
>
> // attach flag-geometry to transform-node
> beginEditCP(flag);
> flag->addChild(makeNodeFor(::flagGeo));
> endEditCP(flag);
>
> // build flag pole
> NodePtr pole = makeCylinder(poleHeight, poleDia, 24, true, true, true);
> MaterialPtr woodMat = createWoodMaterial();
> GeometryPtr cyl = GeometryPtr::dcast(pole->getCore());
> beginEditCP(cyl);
> cyl->setMaterial(woodMat);
> endEditCP(cyl);
>
> // attach objects to group node
> beginEditCP(flagScene);
> flagScene->addChild(flag);
> flagScene->addChild(pole);
> endEditCP(flagScene);
>
> return flagScene;
> }
>
> NodePtr buildFBOScene( int argc, char ** argv )
> {
> PointLightPtr light;
> NodePtr fboRoot = makeCoredNode<PointLight>(&light);
> ::fboCamBeacon = makeNodeFor(Transform::create());
>
> // attach camera beacon to root node
> beginEditCP(fboRoot);
> fboRoot->addChild(::fboCamBeacon);
> endEditCP(fboRoot);
>
> // set camera beacon as light beacon (-> headlight)
> beginEditCP(light);
> light->setBeacon(::fboCamBeacon);
> light->setOn(true);
> endEditCP(light);
>
> // load given model, the cow, or make a torus
> NodePtr scene;
> if(argc >= 2)
> scene = SceneFileHandler::the().read(argv[1]);
> else
> scene = SceneFileHandler::the().read("Data/cow.obj.gz");
>
> // fallback if loading failed
> if(!scene)
> scene = makeTorus(0.3, 4, 16, 64);
>
> NodePtr fboScene = makeCoredNode<Transform>(&::fboSceneTrans);
> beginEditCP(fboScene);
> beginEditCP(fboRoot);
> fboScene->addChild(scene);
> fboRoot->addChild(fboScene);
> endEditCP(fboRoot);
> endEditCP(fboScene);
>
> return fboRoot;
> }
>
> void setupFBO( TextureChunkPtr fboTexture, GLUTWindowPtr gwin, NodePtr
> fboScene )
> {
> // setup FBO
> ImagePtr img = Image::create();
> beginEditCP(img);
> img->set(Image::OSG_RGBA_PF, ::fboWidth, ::fboHeight);
> endEditCP(img);
> beginEditCP(fboTexture);
> fboTexture->setMinFilter(GL_LINEAR);
> fboTexture->setMagFilter(GL_LINEAR);
> fboTexture->setTarget(GL_TEXTURE_2D);
> fboTexture->setInternalFormat(GL_RGBA8);
> fboTexture->setImage(img);
> endEditCP(fboTexture);
>
>
> // add background
> GradientBackgroundPtr bg = GradientBackground::create();
> beginEditCP(bg);
> // flag of neutral-moresnet
> bg->addLine(Color3f(0.0, 0.0, 0.8), 0.000);
> bg->addLine(Color3f(0.0, 0.0, 0.8), 0.333);
>
> bg->addLine(Color3f(0.8, 0.8, 0.8), 0.333);
> bg->addLine(Color3f(0.8, 0.8, 0.8), 0.666);
>
> bg->addLine(Color3f(0.0, 0.0, 0.0), 0.666);
> bg->addLine(Color3f(0.0, 0.0, 0.0), 1.000);
> endEditCP(bg);
>
>
> // setup camera
> PerspectiveCameraPtr fboCam = PerspectiveCamera::create();
> beginEditCP(fboCam);
> // we already compensated aspect ratio with the texture/fbo sizes
> fboCam->setAspect(1.0);
> fboCam->setFov(osgdegree2rad(60));
> fboCam->setNear(0.01);
> fboCam->setFar(100);
> fboCam->setBeacon(::fboCamBeacon);
> endEditCP(fboCam);
>
> // create FBOViewport
> ::fboVP = FBOViewport::create();
> beginEditCP(::fboVP);
> ::fboVP->setSize(0, 0, ::fboWidth - 1, ::fboHeight - 1);
> ::fboVP->setStorageWidth(::fboWidth);
> ::fboVP->setStorageHeight(::fboHeight);
> ::fboVP->setBackground(bg);
> ::fboVP->setCamera(fboCam);
> ::fboVP->setParent(gwin);
> // attach texture as render target
> ::fboVP->getTextures().push_back(fboTexture);
> ::fboVP->setRoot(fboScene);
> ::fboVP->setFboOn(true);
> ::fboVP->setReadBuffer(true);
> endEditCP(::fboVP);
>
> // set the fbo camera to show the whole model
> TransformPtr trans = TransformPtr::dcast(::fboCamBeacon->getCore());
> beginEditCP(trans, Transform::MatrixFieldMask);
> trans->setMatrix(showAll(fboScene, fboCam));
> endEditCP(trans, Transform::MatrixFieldMask);
> }
>
> ------------------------------------------------------------------------
>
> -------------------------------------------------------------------------
> This SF.net email is sponsored by: Microsoft
> Defy all challenges. Microsoft(R) Visual Studio 2008.
> http://clk.atdmt.com/MRT/go/vse0120000070mrt/direct/01/
> ------------------------------------------------------------------------
>
> _______________________________________________
> Opensg-users mailing list
> [email protected]
> https://lists.sourceforge.net/lists/listinfo/opensg-users
>
--
Dipl.-Inf. Eik Deistung
Multimediale Information + Präsentation
ZGDV e.V. E-Mail: [EMAIL PROTECTED]
(Computer Graphics Center) WWW : http://www.zgdv.de/
Joachim-Jungius-Str. 11 FAX : +49 381 446088
D-18059 Rostock, Germany Phone : +49 381 4024-169
-------------------------------------------------------------------------
This SF.net email is sponsored by: Microsoft
Defy all challenges. Microsoft(R) Visual Studio 2008.
http://clk.atdmt.com/MRT/go/vse0120000070mrt/direct/01/
_______________________________________________
Opensg-users mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/opensg-users
