Hi Martin
code where are you initialize your extensions and opengl stuff (atm all this
happens in your drawable constructor) needs active opengl context
It's better to move such initialization out of constructor and do it on first
draw or some other place where opengl context already created and active.
Cheers,
Sergey
24.04.2012, 17:48, "Martin Groer" <grosser.mar...@gmx.de>:
> Hello,
>
> I have tried to implement transform feedback in openscenegraph. I posted this
> few weeks ago. Now I have a nice OpenGL example and want to transfer this to
> an osg implementation. In a first (more simple) example, I want to create a
> vertex array object and a vertex buffer object. I create a OpenGL version and
> a OpenSceneGraph version. But my OSG version doesn't work. In the OSG version
> I create my own extension class with the VAO and VBO stuff. After this I
> create my own drawable type, which should draw four vertices, but I see
> nothing. :-(
>
> What is my mistake?
>
> Cheers
>
> Martin
>
> PS: Here is the OpenGL code:
> ------------------------------------------
>
> #include <GL/glew.h>
> #include <GL/gl.h>
> #include <GL/glut.h>
>
> // Buffers
> GLuint myVAO;
> GLuint myVBO;
>
> // Vertex Data
> unsigned int m,n,numVerts; // number of horizontal verts
> float* pm_data; // data pointer
>
> void myInit(void)
> {
> // Vertex Data
> m = 2; // number of horizontal verts
> n = 2; // number of vertical verts
> numVerts = m*n;
> pm_data = new float[numVerts*4];
>
> // generate position mass data
> float x = 0.0;
> float y = 0.0;
> float dx = 1.0/(m-1);
> float dy = 1.0/(n-1);
> for(unsigned int i=0; i < numVerts; i++)
> {
> pm_data[i*4] = x; // x
> pm_data[i*4+1] = y; // y
> pm_data[i*4+2] = 0.0; // z
> pm_data[i*4+3] = 1.0; // mass
>
> x += dx;
>
> if(!((i+1)%m))
> {
> y += dy;
> x = 0.0;
> }
> } // position data are finished
>
> // init VAO
> glGenVertexArrays(1,&myVAO);
>
> // init VBO
> glGenBuffers(1,&myVBO);
>
> // bind VAO and push data into VBO
> glBindVertexArray(myVAO);
> glBindBuffer(GL_ARRAY_BUFFER,myVBO);
> glBufferData(GL_ARRAY_BUFFER, numVerts*sizeof(float)*4, &(pm_data[0]),
> GL_DYNAMIC_COPY);
> glEnableVertexAttribArray(0);
> glVertexAttribPointer(0,4,GL_FLOAT,GL_FALSE,0,0);
> glBindVertexArray(0);
> }
>
> void myDrawImplementation(void)
> {
> glPointSize(5);
> glBindVertexArray(myVAO);
> glDrawArrays(GL_POINTS,0,numVerts);
> glBindVertexArray(0);
> }
>
> void RenderScene(void)
> {
> // Draw myVBO
> myDrawImplementation();
>
> // Flush drawing commands (and swap)
> glutSwapBuffers();
> }
>
> int main (int argc, char* argv[])
> {
> // initialise glut
> glutInit(&argc, argv);
> glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA);
> glutInitWindowSize(512,512);
> glutCreateWindow("Simple (Hello World)");
> glutDisplayFunc(RenderScene);
>
> // initialise glew
> glewInit();
>
> // initialise VAO
> myInit();
>
> // execution loop
> glutMainLoop();
>
> return 0;
> }
>
> Here is my osg code:
> ------------------------------------
>
> #include <osgViewer/Viewer>
> #include <osg/Geode>
> #include <osg/Drawable>
> #include <osg/GLExtensions>
> #include <GL/gl.h>
>
> class MyExtensions
> {
> public:
> MyExtensions()
> {
> // Generate Vertex Array Object
> if(!osg::setGLExtensionFuncPtr(_glGenVertexArrays,"glGenVertexArrays"))
> osg::setGLExtensionFuncPtr(_glGenVertexArrays,"glGenVertexArrays");
>
> // Bind Vertex Array Object
> if(!osg::setGLExtensionFuncPtr(_glBindVertexArray,"glBindVertexArray"))
> osg::setGLExtensionFuncPtr(_glBindVertexArray,"glBindVertexArray");
>
> // Generate Buffer Object
> if(!osg::setGLExtensionFuncPtr(_glGenBuffers,"glGenBuffers"))
> osg::setGLExtensionFuncPtr(_glGenBuffers,"glGenBuffers");
>
> // Bind Buffer Object
> if(!osg::setGLExtensionFuncPtr(_glBindBuffer,"glBindBuffer"))
> osg::setGLExtensionFuncPtr(_glBindBuffer,"glBindBuffer");
>
> // Buffer Data
> if(!osg::setGLExtensionFuncPtr(_glBufferData,"glBufferData"))
> osg::setGLExtensionFuncPtr(_glBufferData,"glBufferData");
>
> // Enable Vertex Attribute Array
> if(!osg::setGLExtensionFuncPtr(_glEnableVertexAttribArray,"glEnableVertexAttribArray"))
> osg::setGLExtensionFuncPtr(_glEnableVertexAttribArray,"glEnableVertexAttribArray");
>
> // Vertex Attribute Pointer
> if(!osg::setGLExtensionFuncPtr(_glVertexAttribPointer,"glVertexAttribPointer"))
> osg::setGLExtensionFuncPtr(_glVertexAttribPointer,"glVertexAttribPointer");
> }
>
> // Vertex Array generate function
> void glGenVertexArrays(GLsizei n, GLuint* arrays) const
> { _glGenVertexArrays(n,arrays); }
>
> // Vertex Array bind function
> void glBindVertexArray(GLuint array) const
> { _glBindVertexArray(array); }
>
> // Enable Vertex Attribute Array
> void glEnableVertexAttribArray(GLuint index) const
> { _glEnableVertexAttribArray(index); }
>
> // define an array of generic vertex attribute data
> void glVertexAttribPointer(GLuint index, GLint size, GLenum type,
> GLboolean normalized,GLsizei stride,
> const GLvoid* pointer) const
> { _glVertexAttribPointer(index,size,type,normalized,stride,pointer); }
>
> // Buffer generate function
> void glGenBuffers(GLsizei n, GLuint* buffers) const
> { _glGenBuffers(n,buffers); }
>
> // Buffer bind function
> void glBindBuffer(GLenum target, GLuint buffer) const
> { _glBindBuffer(target,buffer); }
>
> // Buffer data function
> void glBufferData(GLenum target, GLsizeiptr size, const GLvoid* data,
> GLenum usage) const
> { _glBufferData(target,size,data,usage); }
>
> protected:
>
> typedef void (APIENTRY* GenVertexArrays)(GLsizei, GLuint*);
> typedef void (APIENTRY* BindVertexArray)(GLuint);
> typedef void (APIENTRY* GenBuffers)(GLsizei, GLuint*);
> typedef void (APIENTRY* BindBuffer)(GLenum, GLuint);
> typedef void (APIENTRY* BufferData)(GLenum, GLsizeiptr, const GLvoid*,
> GLenum);
> typedef void (APIENTRY* EnableVertexAttribArray)(GLuint index);
> typedef void (APIENTRY* VertexAttribPointer)(GLuint index, GLint size,
> GLenum type,
> GLboolean normalized, GLsizei
> stride,
> const GLvoid* pointer);
>
> GenVertexArrays _glGenVertexArrays;
> BindVertexArray _glBindVertexArray;
> GenBuffers _glGenBuffers;
> BindBuffer _glBindBuffer;
> BufferData _glBufferData;
> EnableVertexAttribArray _glEnableVertexAttribArray;
> VertexAttribPointer _glVertexAttribPointer;
> };
>
> class MyDrawable : virtual public osg::Drawable
> {
> public:
> MyDrawable()
> {
> ext = new MyExtensions;
> myInit();
> }
>
> // I can't say much about the methods below, but OSG seems to expect
> // that we implement them.
> MyDrawable(const MyDrawable& pg,
> const osg::CopyOp& copyop = osg::CopyOp::SHALLOW_COPY)
> {;}
>
> virtual osg::Object* cloneType() const
> { return new MyDrawable(); }
>
> virtual osg::Object* clone(const osg::CopyOp& copyop) const
> { return new MyDrawable(*this, copyop); }
>
> void myInit()
> {
> // Vertex Data
> m = 2; // number of horizontal verts
> n = 2; // number of vertical verts
> numVerts = m*n;
> pm_data = new float[numVerts*4];
>
> // generate position mass data
> float x = 0.0;
> float y = 0.0;
> float dx = 1.0/(m-1);
> float dy = 1.0/(n-1);
> for(unsigned int i=0; i < numVerts; i++)
> {
> pm_data[i*4] = x; // x
> pm_data[i*4+1] = y; // y
> pm_data[i*4+2] = 0.0; // z
> pm_data[i*4+3] = 1.0; // mass
>
> x += dx;
>
> if(!((i+1)%m))
> {
> y += dy;
> x = 0.0;
> }
> } // position data are finished
>
> // init VAO
> ext->glGenVertexArrays(1,&myVAO);
>
> // init VBO
> ext->glGenBuffers(1,&myVBO);
>
> // bind VAO and push data into VBO
> ext->glBindVertexArray(myVAO);
> ext->glBindBuffer(GL_ARRAY_BUFFER,myVBO);
> ext->glBufferData(GL_ARRAY_BUFFER, numVerts*sizeof(float)*4,
> &(pm_data[0]), GL_DYNAMIC_COPY);
> ext->glEnableVertexAttribArray(0);
> ext->glVertexAttribPointer(0,4,GL_FLOAT,GL_FALSE,0,0);
> ext->glBindVertexArray(0);
> }
>
> virtual void drawImplementation (osg::RenderInfo& renderInfo) const
> {
> glPointSize(5);
> ext->glBindVertexArray(myVAO);
> glDrawArrays(GL_POINTS,0,numVerts);
> ext->glBindVertexArray(0);
> }
>
> protected:
> ~MyDrawable()
> {
> delete ext;
> delete[] pm_data;
> }
>
> // data
> unsigned int m,n,numVerts;
> float* pm_data;
>
> GLuint myVAO;
> GLuint myVBO;
>
> MyExtensions* ext;
> };
>
> int main(int argc, char **argv)
> {
> // my special drawable
> MyDrawable* drawable = new MyDrawable;
>
> // geometry node
> osg::Geode* geode = new osg::Geode;
> geode->addDrawable(drawable);
>
> // Viewer
> ::osg::ref_ptr< osgViewer::Viewer > viewer = new osgViewer::Viewer;
> viewer->setSceneData(geode);
> viewer->realize();
> viewer->run();
>
> return 0;
> }
>
> --
> Empfehlen Sie GMX DSL Ihren Freunden und Bekannten und wir
> belohnen Sie mit bis zu 50,- Euro! https://freundschaftswerbung.gmx.de
> _______________________________________________
> 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
