Hi Sebastian,
I'm compiling under debian jessie 64 bits and am running a NVIDIA GTX 970. The drivers have been updates recently and I am running version 384.69 now.
I included a compilable minimal example based on the osgmultiplerendertargets example. Without VertexAttributeAliasing it generates two texture using MRT, a red and a green one, it then combines these in a second pass to generate the final texture (yellow). (The red and green intermediate textures are shown in small quads to the side.)
When I enable the attribute aliasing (as in the included code), the two textures generated in the MRT pass turn into gradients, as if something has gone wrong with the mapping.
Screenshots:
The expected result (which I get without attribute aliasing): https://ibb.co/kHEogv
The result with aliasing: https://ibb.co/d9cfuFCode:
/* OpenSceneGraph example, osgmultiplerendertargets.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/#include <osg/GLExtensions>
#include <osg/Node>
#include <osg/Geometry>
#include <osg/Notify>
#include <osg/MatrixTransform>
#include <osg/Texture2D>
#include <osg/TextureRectangle>
#include <osg/ColorMask>
#include <osg/Material>
#include <osg/Capability>#include <osgGA/TrackballManipulator>
#include <osgGA/FlightManipulator>
#include <osgGA/DriveManipulator>#include <osgViewer/Viewer>
#include <iostream>
#include <stdio.h>#include <osg/PolygonMode>
//#include "RenderingUtility.h" //to easily view intermediate textures
//
// Below is relatively straight forward example of using the OpenGL multiple render targets (MRT) extension
// to FrameBufferObjects/GLSL shaders.
//
// Another, more sophisticated MRT example can be found in the osgstereomatch example.
//osg::Geode *createScreenQuad(float width,
float height,
float scale,
osg::Vec3 corner)
{
osg::Geometry* geom = osg::createTexturedQuadGeometry(
corner,
osg::Vec3(width, 0, 0),
osg::Vec3(0, height, 0),
0,
0,
scale,
scale);
osg::ref_ptr<osg::Geode> quad = new osg::Geode;
quad->addDrawable(geom);
int values = osg::StateAttribute::OFF | osg::StateAttribute::PROTECTED;
quad->getOrCreateStateSet()->setAttribute(
new osg::PolygonMode(osg::PolygonMode::FRONT_AND_BACK,
osg::PolygonMode::FILL),
values);
quad->getOrCreateStateSet()->setMode(GL_LIGHTING, values);
return quad.release();
}osg::Camera *createHUDCamera(double left=0,
double right=1,
double bottom=0,
double top=1)
{
osg::ref_ptr<osg::Camera> camera = new osg::Camera;
camera->setReferenceFrame(osg::Transform::ABSOLUTE_RF);
camera->setClearMask(GL_DEPTH_BUFFER_BIT);
camera->setRenderOrder(osg::Camera::POST_RENDER);
camera->setAllowEventFocus(false);
camera->setProjectionMatrix(osg::Matrix::ortho2D(left, right, bottom, top));
camera->getOrCreateStateSet()->setMode(GL_LIGHTING, osg::StateAttribute::OFF);
return camera.release();
}osg::ref_ptr<osg::Camera> createTextureDisplayQuad(
const osg::Vec3 &pos,
osg::StateAttribute *tex,
float scale,
float width=0.3,
float height=0.2)
{
osg::ref_ptr<osg::Camera> hc = createHUDCamera();
hc->addChild(createScreenQuad(width, height, scale, pos));
hc->getOrCreateStateSet()->setTextureAttributeAndModes(0, tex);
return hc;
}// The callback modifies an input image.
struct MyCameraPostDrawCallback : public osg::Camera::DrawCallback
{
MyCameraPostDrawCallback(osg::Image* image):
_image(image)
{
}virtual void operator () (const osg::Camera& /*camera*/) const
{
if (_image && _image->getPixelFormat()==GL_RGBA && _image->getDataType()==GL_UNSIGNED_BYTE)
{
// we'll pick out the center 1/2 of the whole image,
int column_start = _image->s()/4;
int column_end = 3*column_start;int row_start = _image->t()/4;
int row_end = 3*row_start;// and then halve their contribution
for(int r=row_start; r<row_end; ++r)
{
unsigned char* data = "" r);
for(int c=column_start; c<column_end; ++c)
{
(*data) = (*data)/2; ++data;
(*data) = (*data)/2; ++data;
(*data) = (*data)/2; ++data;
(*data) = 255; ++data;
}
}_image->dirty();
}
else if (_image && _image->getPixelFormat()==GL_RGBA && _image->getDataType()==GL_FLOAT)
{
// we'll pick out the center 1/2 of the whole image,
int column_start = _image->s()/4;
int column_end = 3*column_start;int row_start = _image->t()/4;
int row_end = 3*row_start;// and then halve their contribution
for(int r=row_start; r<row_end; ++r)
{
float* data = "" r);
for(int c=column_start; c<column_end; ++c)
{
(*data) = (*data)/2.0; ++data;
(*data) = (*data)/2.0; ++data;
(*data) = (*data)/2.0; ++data;
(*data) = 1.0f; ++data;
}
}_image->dirty();
//print out the first three values
float* data = "" 0);
fprintf(stderr,"Float pixel data: r %e g %e b %e\n", data[0], data[1], data[2]);
}
}osg::Image* _image;
};#define NUM_TEXTURES 2
// The quad geometry is used by the render to texture camera to generate multiple textures.
osg::Group* createRTTQuad(unsigned int tex_width, unsigned int tex_height, bool useHDR)
{
osg::Group *top_group = new osg::Group;osg::ref_ptr<osg::Geode> quad_geode = new osg::Geode;
osg::ref_ptr<osg::Vec3Array> quad_coords = new osg::Vec3Array; // vertex coords
// counter-clockwise
quad_coords->push_back(osg::Vec3d(0, 0, -1));
quad_coords->push_back(osg::Vec3d(1, 0, -1));
quad_coords->push_back(osg::Vec3d(1, 1, -1));
quad_coords->push_back(osg::Vec3d(0, 1, -1));osg::ref_ptr<osg::Vec2Array> quad_tcoords = new osg::Vec2Array; // texture coords
quad_tcoords->push_back(osg::Vec2(0, 0));
quad_tcoords->push_back(osg::Vec2(tex_width, 0));
quad_tcoords->push_back(osg::Vec2(tex_width, tex_height));
quad_tcoords->push_back(osg::Vec2(0, tex_height));osg::ref_ptr<osg::Geometry> quad_geom = new osg::Geometry;
osg::ref_ptr<osg::DrawArrays> quad_da = new osg::DrawArrays(osg::PrimitiveSet::QUADS,0,4);osg::ref_ptr<osg::Vec4Array> quad_colors = new osg::Vec4Array;
quad_colors->push_back(osg::Vec4(1.0f,1.0f,1.0f,1.0f));quad_geom->setVertexArray(quad_coords.get());
quad_geom->setTexCoordArray(0, quad_tcoords.get());
quad_geom->addPrimitiveSet(quad_da.get());
quad_geom->setColorArray(quad_colors.get(), osg::Array::BIND_OVERALL);osg::StateSet *stateset = quad_geom->getOrCreateStateSet();
stateset->setMode(GL_LIGHTING,osg::StateAttribute::OFF);stateset->addUniform(new osg::Uniform("width", (int)tex_width));
// Attach shader, glFragData is used to create data for multiple render targets
if (useHDR) {
static const char *shaderSource = {
"uniform int width;"
"void main(void)\n"
"{\n"
" gl_FragData[0] = vec4(-1e-12,0,0,1);\n"
" gl_FragData[1] = vec4(0,1e-12,0,1);\n"
" gl_FragData[2] = vec4(0,0,1e-12,1);\n"
" gl_FragData[3] = vec4(0,0,1e-12,1);\n"
"}\n"
};osg::ref_ptr<osg::Shader> fshader = new osg::Shader( osg::Shader::FRAGMENT , shaderSource);
osg::ref_ptr<osg::Program> program = new osg::Program;
program->addShader(fshader.get());
stateset->setAttributeAndModes(program.get(), osg::StateAttribute::ON | osg::StateAttribute::OVERRIDE );
} else {
static const char *shaderSource = {
"uniform int width;"
"void main(void)\n"
"{\n"
" gl_FragData[0] = vec4(1,0,0,1);\n"
" gl_FragData[1] = vec4(0,1,0,1);\n"
" gl_FragData[2] = vec4(0,0,1,1);\n"
" gl_FragData[3] = vec4(0,0,1,1);\n"
"}\n"
};osg::ref_ptr<osg::Shader> fshader = new osg::Shader( osg::Shader::FRAGMENT , shaderSource);
osg::ref_ptr<osg::Program> program = new osg::Program;
program->addShader(fshader.get());
stateset->setAttributeAndModes(program.get(), osg::StateAttribute::ON | osg::StateAttribute::OVERRIDE );
}quad_geode->addDrawable(quad_geom.get());
top_group->addChild(quad_geode.get());
return top_group;
}osg::TextureRectangle* textureRect[NUM_TEXTURES] = {0,0}; //moved to global scope to easily view intermediate textures
// Here a scene consisting of a single quad is created. This scene is viewed by the screen camera.
// The quad is textured using a shader and the multiple textures generated in the RTT stage.
osg::Node* createScene(osg::Node* cam_subgraph, unsigned int tex_width, unsigned int tex_height, bool useHDR, bool useImage, bool useMultiSample)
{
if (!cam_subgraph) return 0;// create a group to contain the quad and the pre render camera.
osg::Group* parent = new osg::Group;// textures to render to and to use for texturing of the final quad
//osg::TextureRectangle* textureRect[NUM_TEXTURES] = {0,0,0,0};for (int i=0;i<NUM_TEXTURES;i++) {
textureRect[i] = new osg::TextureRectangle;
textureRect[i]->setTextureSize(tex_width, tex_height);
textureRect[i]->setInternalFormat(GL_RGBA);
textureRect[i]->setFilter(osg::Texture2D::MIN_FILTER,osg::Texture2D::LINEAR);
textureRect[i]->setFilter(osg::Texture2D::MAG_FILTER,osg::Texture2D::LINEAR);if (useHDR)
{
// Default HDR format
textureRect[i]->setInternalFormat(GL_RGBA32F_ARB);// GL_FLOAT_RGBA32_NV might be supported on pre 8-series GPUs
//textureRect[i]->setInternalFormat(GL_FLOAT_RGBA32_NV);// GL_RGBA16F_ARB can be used with this example,
// but modify e-12 and e12 in the shaders accordingly
//textureRect[i]->setInternalFormat(GL_RGBA16F_ARB);textureRect[i]->setSourceFormat(GL_RGBA);
textureRect[i]->setSourceType(GL_FLOAT);
}
}// first create the geometry of the quad
{
osg::Geometry* polyGeom = new osg::Geometry();polyGeom->setSupportsDisplayList(false);
osg::Vec3Array* vertices = new osg::Vec3Array;
osg::Vec2Array* texcoords = new osg::Vec2Array;vertices->push_back(osg::Vec3d(0,0,0));
texcoords->push_back(osg::Vec2(0,0));vertices->push_back(osg::Vec3d(1,0,0));
texcoords->push_back(osg::Vec2(tex_width,0));vertices->push_back(osg::Vec3d(1,0,1));
texcoords->push_back(osg::Vec2(tex_width,tex_height));vertices->push_back(osg::Vec3d(0,0,1));
texcoords->push_back(osg::Vec2(0,tex_height));polyGeom->setVertexArray(vertices);
polyGeom->setTexCoordArray(0,texcoords);osg::Vec4Array* colors = new osg::Vec4Array;
colors->push_back(osg::Vec4(1.0f,1.0f,1.0f,1.0f));
polyGeom->setColorArray(colors, osg::Array::BIND_OVERALL);polyGeom->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::QUADS,0,vertices->size()));
// now we need to add the textures (generated by RTT) to the Drawable.
osg::StateSet* stateset = new osg::StateSet;
for (int i=0;i<NUM_TEXTURES;i++){
stateset->setTextureAttributeAndModes(i, textureRect[i], osg::StateAttribute::ON);
}polyGeom->setStateSet(stateset);
// Attach a shader to the final quad to combine the input textures.
if (useHDR) {
static const char *shaderSource = {
"uniform sampler2DRect textureID0;\n"
"uniform sampler2DRect textureID1;\n"
"uniform sampler2DRect textureID2;\n"
"uniform sampler2DRect textureID3;\n"
"uniform float width;\n"
"uniform float height; \n"
"void main(void)\n"
"{\n"
" gl_FragData[0] = \n"
" vec4( -1e12 * texture2DRect( textureID0, gl_TexCoord[0].st ).rgb, 1) + \n"
" vec4( 1e12 * texture2DRect( textureID1, gl_TexCoord[0].st ).rgb, 1) + \n"
" vec4( 1e12 * texture2DRect( textureID2, gl_TexCoord[0].st ).rgb, 1) + \n"
" vec4(-0.5e12 * texture2DRect( textureID3, gl_TexCoord[0].st ).rgb, 1); \n"
"}\n"
};
osg::ref_ptr<osg::Shader> fshader = new osg::Shader( osg::Shader::FRAGMENT , shaderSource);
osg::ref_ptr<osg::Program> program = new osg::Program;
program->addShader( fshader.get());
stateset->setAttributeAndModes( program.get(), osg::StateAttribute::ON | osg::StateAttribute::OVERRIDE );
} else {
static const char *shaderSource = {
"uniform sampler2DRect textureID0;\n"
"uniform sampler2DRect textureID1;\n"
"uniform sampler2DRect textureID2;\n"
"uniform sampler2DRect textureID3;\n"
"void main(void)\n"
"{\n"
" gl_FragData[0] = \n"
" vec4(texture2DRect( textureID0, gl_TexCoord[0].st ).rgb, 1) + \n"
" vec4(texture2DRect( textureID1, gl_TexCoord[0].st ).rgb, 1) + \n"
" vec4(texture2DRect( textureID2, gl_TexCoord[0].st ).rgb, 1) + \n"
" -0.5*vec4(texture2DRect( textureID3, gl_TexCoord[0].st ).rgb, 1); \n"
"}\n"
};
osg::ref_ptr<osg::Shader> fshader = new osg::Shader( osg::Shader::FRAGMENT , shaderSource);
osg::ref_ptr<osg::Program> program = new osg::Program;
program->addShader( fshader.get());
stateset->setAttributeAndModes( program.get(), osg::StateAttribute::ON | osg::StateAttribute::OVERRIDE );}
stateset->addUniform(new osg::Uniform("textureID0", 0));
stateset->addUniform(new osg::Uniform("textureID1", 1));
stateset->addUniform(new osg::Uniform("textureID2", 2));
stateset->addUniform(new osg::Uniform("textureID3", 3));//stateset->setDataVariance(osg::Object::DYNAMIC);
osg::Geode* geode = new osg::Geode();
geode->addDrawable(polyGeom);parent->addChild(geode);
}// now create the camera to do the multiple render to texture
{
osg::Camera* camera = new osg::Camera;// set up the background color and clear mask.
camera->setClearColor(osg::Vec4(0.1f,0.1f,0.3f,1.0f));
camera->setClearMask(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);// the camera is going to look at our input quad
camera->setProjectionMatrix(osg::Matrix::ortho2D(0,1,0,1));
camera->setReferenceFrame(osg::Transform::ABSOLUTE_RF);
camera->setViewMatrix(osg::Matrix::identity());// set viewport
camera->setViewport(0, 0, tex_width, tex_height);// set the camera to render before the main camera.
camera->setRenderOrder(osg::Camera::PRE_RENDER);// tell the camera to use OpenGL frame buffer objects
camera->setRenderTargetImplementation(osg::Camera::FRAME_BUFFER_OBJECT);// attach the textures to use
for (int i=0; i<NUM_TEXTURES; i++) {
if (useMultiSample)
camera->attach(osg::Camera::BufferComponent(osg::Camera::COLOR_BUFFER0+i), textureRect[i], 0, 0, false, 4, 4);
else
camera->attach(osg::Camera::BufferComponent(osg::Camera::COLOR_BUFFER0+i), textureRect[i]);}
#if 0
// test for new glEnablei/glDisablei functionality.
camera->getOrCreateStateSet()->setAttribute(new osg::Enablei(GL_BLEND, 0));
camera->getOrCreateStateSet()->setAttribute(new osg::Disablei(GL_BLEND, 1));
#endif// we can also read back any of the targets as an image, modify this image and push it back
if (useImage) {
// which texture to get the image from
const int tex_to_get = 0;osg::Image* image = new osg::Image;
if (useHDR) {
image->allocateImage(tex_width, tex_height, 1, GL_RGBA, GL_FLOAT);
} else {
image->allocateImage(tex_width, tex_height, 1, GL_RGBA, GL_UNSIGNED_BYTE);
}// attach the image so its copied on each frame.
camera->attach(osg::Camera::BufferComponent(osg::Camera::COLOR_BUFFER0 + tex_to_get), image);camera->setPostDrawCallback(new MyCameraPostDrawCallback(image));
// push back the image to the texture
textureRect[tex_to_get]->setImage(0, image);
}// add the subgraph to render
camera->addChild(cam_subgraph);parent->addChild(camera);
}return parent;
}int main( int argc, char **argv )
{
// use an ArgumentParser object to manage the program arguments.
osg::ArgumentParser arguments(&argc,argv);// set up the usage document, in case we need to print out how to use this program.
arguments.getApplicationUsage()->setDescription(arguments.getApplicationName() + " demonstrates the use of multiple render targets (MRT) with frame buffer objects (FBOs). A render to texture (RTT) camera is used to render to four textures using a single shader. The four textures are then combined to texture the viewed geometry.");
arguments.getApplicationUsage()->setCommandLineUsage(arguments.getApplicationName()+" [options] ...");
arguments.getApplicationUsage()->addCommandLineOption("-h or --help","Display this information.");
arguments.getApplicationUsage()->addCommandLineOption("--width","Set the width of the render to texture.");
arguments.getApplicationUsage()->addCommandLineOption("--height","Set the height of the render to texture.");
arguments.getApplicationUsage()->addCommandLineOption("--image","Render one of the targets to an image, then apply a post draw callback to modify it and use this image to update the final texture. Print some texture values when using HDR.");
arguments.getApplicationUsage()->addCommandLineOption("--hdr","Use high dynamic range (HDR). Create floating point textures to render to.");// construct the viewer.
osgViewer::Viewer viewer(arguments);// if user request help write it out to cout.
if (arguments.read("-h") || arguments.read("--help"))
{
arguments.getApplicationUsage()->write(std::cout);
return 1;
}unsigned tex_width = 512;
unsigned tex_height = 512;
while (arguments.read("--width", tex_width)) {}
while (arguments.read("--height", tex_height)) {}bool useHDR = false;
while (arguments.read("--hdr")) { useHDR = true; }bool useImage = false;
while (arguments.read("--image")) { useImage = true; }bool useMultiSample = false;
while (arguments.read("--ms")) { useMultiSample = true; }osg::Group* subGraph = createRTTQuad(tex_width, tex_height, useHDR);
osg::Group* rootNode = new osg::Group();
rootNode->addChild(createScene(subGraph, tex_width, tex_height, useHDR, useImage, useMultiSample));rootNode->addChild(createScene(subGraph, tex_width, tex_height, useHDR, useImage, useMultiSample));
//Some code to view the intermediate textures
osg::ref_ptr<osg::Camera> testTex =
createTextureDisplayQuad(osg::Vec3(0, 0.7, 0),
textureRect[0],
tex_width);
osg::ref_ptr<osg::Camera> testTex2 =
createTextureDisplayQuad(osg::Vec3(0, 0.35, 0),
textureRect[1],
tex_width);rootNode->addChild(testTex);
rootNode->addChild(testTex2);// add model to the viewer.
viewer.setSceneData( rootNode );
viewer.realize();
viewer.getCamera()->getGraphicsContext()->getState()->setUseVertexAttributeAliasing(true);return viewer.run();
}Thank you!!
Cheers,
antiro[/code]------------------
Read this topic online here:
http://forum.openscenegraph.org/viewtopic.php?p=71613#71613_______________________________________________
osg-users mailing list
osg-users@lists.openscenegraph.org
http://lists.openscenegraph.org/listinfo.cgi/osg-users-openscenegraph.org
_______________________________________________ osg-users mailing list osg-users@lists.openscenegraph.org http://lists.openscenegraph.org/listinfo.cgi/osg-users-openscenegraph.org
