basic openGL, vertex buffers and pyglet

Question

Edit: rotoglup found the problems in my code, adding the shaders I had removed completed the solution. See my answer below for the correct code (with shaders).

Hi all !

I'm trying to learn some basics of modern OpenGL from this tutorial.

I'd like to do it with python/pyglet instead of C++ though. I know pyglet can abstract much of the low level OpenGL away; I want to understand some of the basics before moving on to hiding them behind layers of abstraction though.

My problem is extremely simple: the code below only draws a single point instead of the 3 I am expecting. My code is, as far as I can tell, identical to the C++ in the tutorial, except for the removal of vertex and fragment shaders (done via gletools in python), which appears to make no difference to my problem.

Simplifying things to a single point shows behaviour I do not understand (the first coordinate appears to be the only one that affects anything), leading me back to my belief that I've simply failed to understand something very basic about either pyglet, OpenGL, or even 3D in general :p

Here's the relevant code:

import pyglet
from pyglet.gl import *

window = pyglet.window.Window()

positionBufferObject = GLuint()
vao = GLuint()

vertexPositions = [0.0, 0.0, 0.0,
                   0.25, 0.0, 0.0,
                   1.75, 1.75, 0.0]

vertexPositionsGl = (GLfloat * len(vertexPositions))(*vertexPositions)

@window.event
def on_draw():
    glBindBuffer(GL_ARRAY_BUFFER, positionBufferObject)
    glEnableVertexAttribArray(0)
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0)
    glDrawArrays(GL_POINTS, 0, 3)
    glDisableVertexAttribArray(0)

glGenBuffers(1, positionBufferObject)
glBindBuffer(GL_ARRAY_BUFFER, positionBufferObject)
glBufferData(GL_ARRAY_BUFFER, len(vertexPositionsGl)*4, vertexPositionsGl, GL_STATIC_DRAW)
glBindBuffer(GL_ARRAY_BUFFER, 0)

glClearColor(0.0, 0.0, 0.0, 0.0)
pyglet.app.run()

You mean that with the corrected code, you still have a single point drawn ? Is this point drawn in the middle of the screen ? If you change the first coordinates, does the point move ? — rotoglup, Jan 06 '11 at 22:06
With the corrected code, the best I get is still a single point that does not move with the w coordinate at 1 and by passing the size in bytes. If I remove the w coordinates and change glVertexAttribPointer accordingly, I get nothing. I am thoroughly confused ! — Nicolas Lefebvre, Jan 07 '11 at 07:36
Correction : w has to be at 0 for something at all to show up, which only makes me more confused. — Nicolas Lefebvre, Jan 07 '11 at 07:42
This is probably related to some clipping occuring without you knowing. As you don't setup any projection or transform matrix, it is certainly that your third point is offscreen. The others may be clipped as well because of the Z value. I don't have the default opengl projection in mind though. You should try to call glOrtho to install a projection. You should also try to draw a triangle, it will make things graphically more obvious if some points are at infinity or outside the screen. — rotoglup, Jan 07 '11 at 10:51

rotoglup · Accepted Answer · 2011-01-06T22:10:59.103

5

glDrawArrays(GL_POINTS, 0, 1)

instructs to draw 1 point, in your tutorial, 1 is 3 :

glDrawArrays(GL_POINTS, 0, 3)

Notice also that the 4th (w) component of your vertices should be 1, not 0 :

  vertexPositions = [0.0, 0.0, 0.0, 1.0,
                     0.25, 0.0, 0.0, 1.0,
                     1.75, 1.75, 0.0, 1.0]

Alternatively, you could remove the w component,

  vertexPositions = [0.0, 0.0, 0.0,
                     0.25, 0.0, 0.0,
                     1.75, 1.75, 0.0]

and change the following call to :

glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0)

Another thing, I'm not an expert in pyglet, but it's possible that glBufferData, like its C counterpart, take a size in bytes, not in elements. Each float being 4 bytes, you could try :

glBufferData(GL_ARRAY_BUFFER, len(vertexPositionsGl)*4, vertexPositionsGl, GL_STATIC_DRAW)

edited Jan 06 '11 at 22:10

answered Jan 06 '11 at 19:30

rotoglup

5,223
25
37

Thanks for the answer ! I've edited my question with your suggestions (I had actually tried the correct version of the drawArray call but forgot to restore it before copying my code). The issue still exists though... I'm starting to wonder if something is wrong with my version of pyglet, I had to install the development version in order to use gletools. – Nicolas Lefebvre Jan 06 '11 at 22:00
Thanks for the (further) answer ! Still no joy unfortunately... I'm starting to wonder if this is specific to pyglet instead of being an OpenGL issue. I'll try the pyglet mailing list and report back ! – Nicolas Lefebvre Jan 07 '11 at 07:34
That may be a solution. If you're all new to 3d, opengl, etc, you should also try to follow a simpler tutorial, without buffer objects, using plain old glVertex calls. It would make things more obvious by removing the python float to bytes problems for sure. You could try NeHe tutorials. – rotoglup Jan 07 '11 at 10:53
Thanks once again, I finally got things working and added the corrected code as an answer. I had incorrectly assumed the shaders could be skipped for now when they in fact were necessary but failed to work because of the issues you corrected in my code ! I realize starting with buffer objects and shader is a bit risky but I wanted to understand the differences between "good old" OpenGL (having already read some of the NeHe tutorials) and the more recent way of doing it :) – Nicolas Lefebvre Jan 07 '11 at 11:10

Nicolas Lefebvre · Answer 2 · 2011-01-08T14:59:28.447

I finally got this right !

It seems I was being misled by the fact that fiddling with vertices, glDrawArrays and glVertexAttribPointer sometimes resulted in a single dot being shown. This appears to be an accident: with the corrections provided by rotoglup's answer, nothing at all is drawn. This is the "correct" behaviour for the code in my original question.

An inventory of my mistakes in case it helps anyone:

setting the w coordinate to 0, instead of 1, completely missing the explanations for clip-space transformation in the tutorial.
giving glBufferData the size of the buffer in vertices when it expects bytes.
removing the vertex and fragment shaders (to simplify the code while looking for the above two issues). This ensured that nothing would ever be rendered... except the (buggy ?) single dot I was sometimes getting.

For the record, the code below displays a single triangle, with pass through shaders, in what I hope to be up to date and correct OpenGL. Requirements are pyglet and gletools.

import pyglet
from pyglet.gl import *
from gletools import ShaderProgram, FragmentShader, VertexShader

window = pyglet.window.Window()

positionBufferObject = GLuint()

vertexPositions = [0.75, 0.75, 0.0, 1.0,
                   0.75, -0.75, 0.0, 1.0,
                   -0.75, -0.75, 0.0, 1.0]
vertexPositionsGl = (GLfloat * len(vertexPositions))(*vertexPositions)

program = ShaderProgram(
    FragmentShader('''
    #version 330
    out vec4 outputColor;
    void main()
    {
       outputColor = vec4(1.0f, 1.0f, 1.0f, 1.0f);
    }'''),
    VertexShader('''
    #version 330
    layout(location = 0) in vec4 position;
    void main()
    {
        gl_Position = position;
    }''')
)

@window.event
def on_draw():
    with program:
        glBindBuffer(GL_ARRAY_BUFFER, positionBufferObject)
        glEnableVertexAttribArray(0)
        glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, 0)
        glDrawArrays(GL_TRIANGLES, 0, 3)
        glDisableVertexAttribArray(0)

glGenBuffers(1, positionBufferObject)
glBindBuffer(GL_ARRAY_BUFFER, positionBufferObject)
glBufferData(GL_ARRAY_BUFFER, len(vertexPositionsGl)*4, vertexPositionsGl, GL_STATIC_DRAW)
glBindBuffer(GL_ARRAY_BUFFER, 0)

pyglet.app.run()

basic openGL, vertex buffers and pyglet

2 Answers2

Linked