Index: include/osg/GL2Extensions =================================================================== --- include/osg/GL2Extensions (revision 13596) +++ include/osg/GL2Extensions (working copy) @@ -407,6 +407,7 @@ #define GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW 0x900D #define GL_INT_SAMPLER_CUBE_MAP_ARRAY 0x900E #define GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY 0x900F +#define GL_INTERLEAVED_ATTRIBS 0x8C8C #endif // ARB_shader_atomic_counters @@ -478,6 +479,15 @@ #ifndef GL_ARB_seamless_cube_map #define GL_TEXTURE_CUBE_MAP_SEAMLESS 0x884F #endif +// Transform feedback extensions +#ifndef GL_TRANSFORM_FEEDBACK +#define GL_TRANSFORM_FEEDBACK 0x8E22 +#define GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED 0x8E23 +#define GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE 0x8E24 +#define GL_TRANSFORM_FEEDBACK_BINDING 0x8E25 +#define GL_TRANSFORM_FEEDBACK_BUFFER 0x8C8E +#define GL_RASTERIZER_DISCARD 0x8C89 +#endif namespace osg { @@ -551,6 +561,7 @@ void glStencilMaskSeparate(GLenum face, GLuint mask) const; void glAttachShader(GLuint program, GLuint shader) const; void glBindAttribLocation(GLuint program, GLuint index, const GLchar *name) const; + void glTransformFeedbackVaryings(GLuint program, GLsizei count, const char **varyings, GLenum bufferMode) const; void glCompileShader(GLuint shader) const; GLuint glCreateProgram(void) const; GLuint glCreateShader(GLenum type) const; @@ -714,7 +725,17 @@ // ARB_compute_shader void glDispatchCompute( GLuint numGroupsX, GLuint numGroupsY, GLuint numGroupsZ ) const; + // Vertex Arrays + void glBindVertexArray( GLuint arrayValue ) const; + void glGenVertexArrays(GLsizei count, GLuint *value ) const; + // Transform feedback + void glGenTransformFeedbacks( GLsizei n, GLuint *ids ); + void glBindTransformFeedback(GLenum target, GLuint id) const; + void glBeginTransformFeedback(GLenum primitiveMode) const; + void glEndTransformFeedback() const; + void glDrawTransformFeedback(GLenum mode, GLuint id ) const; + protected: ~GL2Extensions() {} @@ -740,6 +761,7 @@ typedef void (GL_APIENTRY * StencilMaskSeparateProc)(GLenum face, GLuint mask); typedef void (GL_APIENTRY * AttachShaderProc)(GLuint program, GLuint shader); typedef void (GL_APIENTRY * BindAttribLocationProc)(GLuint program, GLuint index, const GLchar *name); + typedef void (GL_APIENTRY * TranformFeedbackVaryingsProc)(GLuint program, GLsizei count, const char **varyings, GLenum bufferMode); typedef void (GL_APIENTRY * CompileShaderProc)(GLuint shader); typedef GLuint (GL_APIENTRY * CreateProgramProc)(void); typedef GLuint (GL_APIENTRY * CreateShaderProc)(GLenum type); @@ -882,6 +904,13 @@ typedef void (GL_APIENTRY * UniformMatrix4x3dvProc)( GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ); typedef void (GL_APIENTRY * GetActiveAtomicCounterBufferivProc)( GLuint program, GLuint bufferIndex, GLenum pname, GLint* params ); typedef void (GL_APIENTRY * DispatchComputeProc)( GLuint numGroupsX, GLuint numGroupsY, GLuint numGroupsZ ); + typedef void (GL_APIENTRY * BindVertexArray)(GLuint); + typedef void (GL_APIENTRY * GenVertexArray)(GLsizei, GLuint*); + typedef void (GL_APIENTRY * BindTransformFeedback)(GLenum target, GLuint id); + typedef void (GL_APIENTRY * BeginTransformFeedback)(GLenum primitiveMode); + typedef void (GL_APIENTRY * EndTransformFeedback)(); + typedef void (GL_APIENTRY * DrawTransformFeedback)( GLenum mode, GLuint id ); + typedef void (GL_APIENTRY * GenTransformFeedbacks) ( GLsizei n, GLuint* ids); BlendEquationSeparateProc _glBlendEquationSeparate; DrawBuffersProc _glDrawBuffers; @@ -890,6 +919,7 @@ StencilMaskSeparateProc _glStencilMaskSeparate; AttachShaderProc _glAttachShader; BindAttribLocationProc _glBindAttribLocation; + TranformFeedbackVaryingsProc _glTransformFeedbackVaryings; CompileShaderProc _glCompileShader; CreateProgramProc _glCreateProgram; CreateShaderProc _glCreateShader; @@ -1051,6 +1081,16 @@ // ARB_compute_shader DispatchComputeProc _glDispatchCompute; + // Vertex Arrays + BindVertexArray _glBindVertexArray; + GenVertexArray _glGenVertexArray; + + // Transform feedback + BindTransformFeedback _glBindTransformFeedback; + BeginTransformFeedback _glBeginTransformFeedback; + EndTransformFeedback _glEndTransformFeedback; + DrawTransformFeedback _glDrawTransformFeedback; + GenTransformFeedbacks _glGenTransformFeedbacks; }; } Index: include/osg/Program =================================================================== --- include/osg/Program (revision 13596) +++ include/osg/Program (working copy) @@ -124,6 +124,11 @@ /** Remove a uniform block binding. */ void removeBindUniformBlock(const std::string& name); + /** Add transform feedback attribute */ + void addTransformFeedbackAttrib(char* name); + + + /** Simple class for wrapping up the data used in glProgramBinary and glGetProgramBinary. * On the first run of your application Programs should be assigned an empty ProgramBinary. * Before your application exits it should retrieve the program binary via @@ -183,10 +188,12 @@ typedef std::map AttribBindingList; typedef std::map FragDataBindingList; typedef std::map UniformBlockBindingList; + typedef std::vector TransformFeedbackBindingList; const AttribBindingList& getAttribBindingList() const { return _attribBindingList; } const FragDataBindingList& getFragDataBindingList() const { return _fragDataBindingList; } const UniformBlockBindingList& getUniformBlockBindingList() const { return _uniformBlockBindingList; } + TransformFeedbackBindingList& getTransformFeedbackBindingList() { return _transformFeedbackBindingList; } /** Return true if this Program represents "fixed-functionality" rendering */ bool isFixedFunction() const; @@ -371,6 +378,7 @@ AttribBindingList _attribBindingList; FragDataBindingList _fragDataBindingList; UniformBlockBindingList _uniformBlockBindingList; + TransformFeedbackBindingList _transformFeedbackBindingList; typedef std::vector< ref_ptr > ShaderList; ShaderList _shaderList; @@ -382,7 +390,7 @@ GLint _geometryInputType; GLint _geometryOutputType; - + /** Parameter maintained with glDispatchCompute */ GLint _numGroupsX; GLint _numGroupsY; Index: examples/osgtransformfeedback/osgtransformfeedback.cpp =================================================================== --- examples/osgtransformfeedback/osgtransformfeedback.cpp (revision 0) +++ examples/osgtransformfeedback/osgtransformfeedback.cpp (working copy) @@ -0,0 +1,228 @@ +/* OpenSceneGraph example, osgtransformfeedback. +* +* 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 +#include +#include + +int VERTEX_POSITION = 0; + +// Store the transformed vertices in this buffer +GLuint FeedbackName(0); +GLuint FeedbackArrayBufferName(0); +GLuint FeedbackVertexArrayName(0); + +void initTransformFeedback(const unsigned int contextID, const osg::Drawable* geom) +{ + osg::GLBufferObject::Extensions* glBufferExtension = osg::GLBufferObject::getExtensions(contextID, true); + osg::GL2Extensions* gl2ext = osg::GL2Extensions::Get(contextID, true); + + // Vertex Count + unsigned int vertexCount = geom->asGeometry()->getPrimitiveSet(0)->getNumIndices(); + + // Gen Feedback array + glBufferExtension->glGenBuffers(1, &FeedbackArrayBufferName); + glBufferExtension->glBindBuffer(GL_ARRAY_BUFFER_ARB, FeedbackArrayBufferName); + glBufferExtension->glBufferData(GL_ARRAY_BUFFER_ARB, sizeof(osg::Vec4f) * vertexCount, NULL, GL_STATIC_DRAW); + glBufferExtension->glBindBuffer(GL_ARRAY_BUFFER_ARB, 0); + + // Build a vertex array object + gl2ext->glGenVertexArrays(1, &FeedbackVertexArrayName); + gl2ext->glBindVertexArray(FeedbackVertexArrayName); + glBufferExtension->glBindBuffer(GL_ARRAY_BUFFER_ARB, FeedbackArrayBufferName); + gl2ext->glVertexAttribPointer(VERTEX_POSITION, 4, GL_FLOAT, GL_FALSE, sizeof(osg::Vec4f), 0); + glBufferExtension->glBindBuffer(GL_ARRAY_BUFFER_ARB, 0); + gl2ext->glEnableVertexAttribArray(VERTEX_POSITION); + gl2ext->glBindVertexArray(0); + + // Generate transform feedback buffer objects + gl2ext->glGenTransformFeedbacks(1, &FeedbackName); + gl2ext->glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, FeedbackName); + glBufferExtension->glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, FeedbackArrayBufferName); + gl2ext->glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0); +} + +// Transform Feedback Draw Callback +class TransformFeedbackDrawCallback : public osg::Drawable::DrawCallback +{ + virtual void drawImplementation(osg::RenderInfo& renderInfo,const osg::Drawable* drawable) const + { + // Transform feedback extensions + osg::GL2Extensions* gl2ext = osg::GL2Extensions::Get(renderInfo.getContextID(), true); + + // Init the Array Buffer + if(FeedbackArrayBufferName == 0) + initTransformFeedback(renderInfo.getContextID(), drawable); + + // First draw, capture the attributes + // Disable rasterisation, vertices processing only! + glEnable(GL_RASTERIZER_DISCARD); + + gl2ext->glBindVertexArray(0); + gl2ext->glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, FeedbackName); + gl2ext->glBeginTransformFeedback(GL_TRIANGLES); + drawable->drawImplementation(renderInfo); + gl2ext->glEndTransformFeedback(); + gl2ext->glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0); + + glDisable(GL_RASTERIZER_DISCARD); + } +}; + +// Render Transform Feedback Draw Callback +class RenderTransformFeedbackDrawCallback : public osg::Drawable::DrawCallback +{ + virtual void drawImplementation(osg::RenderInfo& renderInfo,const osg::Drawable* drawable) const + { + osg::GL2Extensions* gl2ext = osg::GL2Extensions::Get(renderInfo.getContextID(), true); + gl2ext->glBindVertexArray(FeedbackVertexArrayName); + gl2ext->glDrawTransformFeedback(GL_TRIANGLES, FeedbackName); + } +}; + +osg::ref_ptr TransformFeedbackProgram() +{ + osg::ref_ptr program = new osg::Program; + + char transformShaderSource[] = + "#version 400 compatibility \n" + " \n" + "void main() \n" + "{ \n" + " gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; \n" + "} \n"; + + program->addShader(new osg::Shader(osg::Shader::VERTEX, transformShaderSource)); + + // Add Transform Feedback Varyings + program->addTransformFeedbackAttrib("gl_Position"); + + return program; +} + +osg::ref_ptr RenderFeedbackProgram() +{ + osg::ref_ptr program = new osg::Program; + + char vertexShaderSource[] = + "#version 400 compatibility \n" + " \n" + "void main() \n" + "{ \n" + " gl_Position = gl_Vertex; \n" + "} \n"; + + char fragmentShaderSource[] = + "#version 400 compatibility \n" + " \n" + "out vec4 Color; \n" + " \n" + "void main() \n" + "{ \n" + " Color = vec4(1.0, 0.0, 0.0, 0.0); \n" + "} \n"; + + program->addShader(new osg::Shader(osg::Shader::VERTEX, vertexShaderSource)); + program->addShader(new osg::Shader(osg::Shader::FRAGMENT, fragmentShaderSource)); + + return program; +} + +osg::Node* createTransformFeedbackScene(osg::GraphicsContext* gc, osg::Geode* model) +{ + //////////////////////////////////////////////////////////////////////////////////// + // Setup root node + osg::Group* rootNode = new osg::Group; + + //////////////////////////////////////////////////////////////////////////////////// + // Transform vertices + osg::StateSet* statesetBin1 = new osg::StateSet(); + statesetBin1->setAttributeAndModes(TransformFeedbackProgram()); + model->setStateSet(statesetBin1); + model->getDrawable(0)->setDrawCallback(new TransformFeedbackDrawCallback()); + rootNode->addChild(model); + + ////////////////////////////////////////////////////////////////////////////////////// + // Render vertices + osg::Geode* renderTransformGeode = new osg::Geode(); + osg::Geometry* geom = new osg::Geometry(); + renderTransformGeode->addDrawable(geom); + geom->setUseDisplayList(false); + osg::StateSet* statesetBin2 = new osg::StateSet(); + statesetBin2->setAttributeAndModes(RenderFeedbackProgram()); + geom->setStateSet(statesetBin2); + geom->setDrawCallback(new RenderTransformFeedbackDrawCallback()); + rootNode->addChild(renderTransformGeode); + + // Return RootNode + return rootNode; +} + +osg::Geode* CreateGeometry() +{ + // create the Geode (Geometry Node) to contain all our osg::Geometry objects. + osg::Geode* geode = new osg::Geode(); + + // create Geometry object to store all the vertices and lines primitive. + osg::Geometry* polyGeom = new osg::Geometry(); + + // note, first coord at top, second at bottom, reverse to that buggy OpenGL image.. + osg::Vec3 myCoords[] = + { + osg::Vec3(-1.0, 0.0, -1.0), + osg::Vec3(1.0, 0.0, -1.0), + osg::Vec3(1.0, 0.0, 1.0), + osg::Vec3(1.0, 0.0, 1.0), + osg::Vec3(-1.0, 0.0, 1.0), + osg::Vec3(-1.0, 0.0, -1.0), + }; + + int numCoords = sizeof(myCoords)/sizeof(osg::Vec3f); + + osg::Vec3Array* vertices = new osg::Vec3Array(numCoords,myCoords); + polyGeom->setVertexArray(vertices); + polyGeom->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::TRIANGLES,0,6)); + polyGeom->setUseDisplayList(false); + + // add the points geometry to the geode. + geode->addDrawable(polyGeom); + + return geode; +} + +int main(int argc, char** argv) +{ + osg::ArgumentParser arguments(&argc, argv); + + // construct the viewer. + osgViewer::Viewer viewer(arguments); + + // read the scene from the list of file specified commandline args + osg::ref_ptr loadedModel = CreateGeometry(); + + if(!loadedModel) + return 0; + + // finally decorate the loaded model so that it has the required multipass/bin scene graph to do the reflection effect. + osg::ref_ptr rootNode = createTransformFeedbackScene(viewer.getCamera()->getGraphicsContext(), loadedModel.get()); + + // set the scene to render + viewer.setSceneData(rootNode); + + return viewer.run(); +} Index: examples/osgtransformfeedback/CMakeLists.txt =================================================================== --- examples/osgtransformfeedback/CMakeLists.txt (revision 0) +++ examples/osgtransformfeedback/CMakeLists.txt (working copy) @@ -0,0 +1,5 @@ +SET(TARGET_SRC osgtransformfeedback.cpp) + +SET(TARGET_EXTERNAL_LIBRARIES ${OPENGL_LIBRARIES} ) +#### end var setup ### +SETUP_EXAMPLE(osgtransformfeedback) Index: examples/CMakeLists.txt =================================================================== --- examples/CMakeLists.txt (revision 13596) +++ examples/CMakeLists.txt (working copy) @@ -158,6 +158,7 @@ ADD_SUBDIRECTORY(osgwidgettable) ADD_SUBDIRECTORY(osgwidgetwindow) ADD_SUBDIRECTORY(osguserdata) + ADD_SUBDIRECTORY(osgtransformfeedback) # GL3/GL4 example ADD_SUBDIRECTORY(osgsimplegl3) Index: src/osg/Program.cpp =================================================================== --- src/osg/Program.cpp (revision 13596) +++ src/osg/Program.cpp (working copy) @@ -205,10 +205,10 @@ if( _numGroupsX < rhs._numGroupsX ) return -1; if( rhs._numGroupsX < _numGroupsX ) return 1; - + if( _numGroupsY < rhs._numGroupsY ) return -1; if( rhs._numGroupsY < _numGroupsY ) return 1; - + if( _numGroupsZ < rhs._numGroupsZ ) return -1; if( rhs._numGroupsZ < _numGroupsZ ) return 1; @@ -424,9 +424,13 @@ dirtyProgram(); // XXX } +void Program::addTransformFeedbackAttrib( char* name) +{ + _transformFeedbackBindingList.push_back(name); + dirtyProgram(); +} - void Program::apply( osg::State& state ) const { const unsigned int contextID = state.getContextID(); @@ -567,7 +571,7 @@ _extensions->glProgramParameteri( _glProgramHandle, GL_GEOMETRY_INPUT_TYPE_EXT, _program->_geometryInputType ); _extensions->glProgramParameteri( _glProgramHandle, GL_GEOMETRY_OUTPUT_TYPE_EXT, _program->_geometryOutputType ); } - + // Detach removed shaders for( unsigned int i=0; i < _shadersToDetach.size(); ++i ) { @@ -601,6 +605,19 @@ _extensions->glBindAttribLocation( _glProgramHandle, itr->second, reinterpret_cast(itr->first.c_str()) ); } + // set any explicit vertex transform feedback bindings + TransformFeedbackBindingList& programTransformFeedbackBindlist = const_cast(_program)->getTransformFeedbackBindingList(); + unsigned int numFeedbackBindings = programTransformFeedbackBindlist.size(); + + if(numFeedbackBindings > 0) + { + OSG_INFO << "Program's transform feedback vertex attrib binding " << std::endl; + + _extensions->glTransformFeedbackVaryings( _glProgramHandle, numFeedbackBindings, + &programTransformFeedbackBindlist[0], GL_INTERLEAVED_ATTRIBS ); + } + + // set any explicit vertex attribute bindings that are set up via osg::State, such as the vertex arrays // that have been aliase to vertex attrib arrays if (state.getUseVertexAttributeAliasing()) @@ -759,7 +776,7 @@ // print atomic counter - if (_extensions->isShaderAtomicCounterSupported() && !atomicCounterMap.empty()) + if (_extensions->isShaderAtomicCounterSupported() && !atomicCounterMap.empty()) { std::vector bufferIndex( atomicCounterMap.size(), 0 ); std::vector uniformIndex; Index: src/osg/GL2Extensions.cpp =================================================================== --- src/osg/GL2Extensions.cpp (revision 13596) +++ src/osg/GL2Extensions.cpp (working copy) @@ -218,6 +218,8 @@ // ARB_compute_shader _glDispatchCompute = rhs._glDispatchCompute; + // Transform freedback + _glTransformFeedbackVaryings = rhs._glTransformFeedbackVaryings; } @@ -600,6 +602,8 @@ // ARB_compute_shader _glDispatchCompute= 0; + // Transform Feedback + _glTransformFeedbackVaryings= 0; return; } @@ -810,6 +814,17 @@ // ARB_compute_shader setGLExtensionFuncPtr(_glDispatchCompute, "glDispatchCompute" ); + // Transform feedback + setGLExtensionFuncPtr(_glTransformFeedbackVaryings, "glTransformFeedbackVaryings" ); + setGLExtensionFuncPtr(_glBindTransformFeedback, "glBindTransformFeedback" ); + setGLExtensionFuncPtr(_glBeginTransformFeedback, "glBeginTransformFeedback" ); + setGLExtensionFuncPtr(_glEndTransformFeedback, "glEndTransformFeedback" ); + setGLExtensionFuncPtr(_glDrawTransformFeedback, "glDrawTransformFeedback" ); + setGLExtensionFuncPtr(_glGenTransformFeedbacks, "glGenTransformFeedbacks"); + + // Buffer Arrays + setGLExtensionFuncPtr(_glBindVertexArray, "glBindVertexArray" ); + setGLExtensionFuncPtr(_glGenVertexArray, "glGenVertexArrays" ); } @@ -943,6 +958,17 @@ } } +void GL2Extensions::glTransformFeedbackVaryings(GLuint program, GLsizei count, const char **varyings, GLenum bufferMode) const +{ + if (_glTransformFeedbackVaryings) + { + _glTransformFeedbackVaryings(program, count, varyings, bufferMode); + } + else + { + NotSupported( "glBindAttribLocation" ); + } +} void GL2Extensions::glCompileShader(GLuint shader) const { @@ -2865,6 +2891,92 @@ } } +void GL2Extensions::glBindVertexArray( GLuint arrayValue ) const +{ + if (_glBindVertexArray) + { + _glBindVertexArray( arrayValue ); + } + else + { + NotSupported( "glBindVertexArray" ); + } +} + +void GL2Extensions::glGenVertexArrays( GLsizei count, GLuint *value ) const +{ + if (_glGenVertexArray) + { + _glGenVertexArray( count, value ); + } + else + { + NotSupported( "glGenVertexArrays" ); + } +} + + +void GL2Extensions::glBindTransformFeedback(GLenum target, GLuint id) const +{ + if (_glBindTransformFeedback) + { + _glBindTransformFeedback( target, id ); + } + else + { + NotSupported( "glBindTransformFeedback" ); + } +} + +void GL2Extensions::glBeginTransformFeedback(GLenum primitiveMode) const +{ + if (_glBeginTransformFeedback) + { + _glBeginTransformFeedback( primitiveMode ); + } + else + { + NotSupported( "glBeginTransformFeedback" ); + } +} + +void GL2Extensions::glEndTransformFeedback() const +{ + if (_glEndTransformFeedback) + { + _glEndTransformFeedback(); + } + else + { + NotSupported( "glEndTransformFeedback" ); + } +} + +void GL2Extensions::glDrawTransformFeedback( GLenum mode, GLuint id ) const +{ + if (_glDrawTransformFeedback) + { + _glDrawTransformFeedback( mode, id ); + } + else + { + NotSupported( "glDrawTransformFeedback" ); + } +} + + +void GL2Extensions::glGenTransformFeedbacks( GLsizei n, GLuint *ids ) +{ + if (_glGenTransformFeedbacks) + { + _glGenTransformFeedbacks( n, ids ); + } + else + { + NotSupported( "glGenTransformFeedbacks" ); + } +} + /////////////////////////////////////////////////////////////////////////// // C++-friendly convenience methods