Fwd: glGenVertexArrays producing 'invalid enumerant' error.

Gordon Wrigley <[email protected]> Tue, 8 Nov 2011 22:46:17 +1100

Newsgroups	gmane.comp.python.opengl.user
Message-ID	<CAD-wiX18JQcz7+6--XqVDGtVYf97K0u9Gm1V6dPyWHb-CsUQ=w@mail.gmail.com>

+list

---------- Forwarded message ----------
From: Gordon Wrigley <[email protected]>
Date: Tue, Nov 8, 2011 at 10:45 PM
Subject: Re: [PyOpenGL-Users] glGenVertexArrays producing 'invalid
enumerant' error.
To: "Mike C. Fletcher" <[email protected]>

I stripped my program right down to the bare minimum and condensed it into
a single file, just 150 lines and 5 separate issues.
The file as attached doesn't run for me.
There are 5 if statements marked with XXX comments as you toggle each one
another problem is resolved / worked around.
After all 5 are toggled it runs and displays a single white triangle.

In order those problems are:
1: enabling ERROR_CHECKING after importing OpenGL.GL causes glShaderSource
to error with "Don't know how to convert parameter 3"
2: glGenVertexArrays is not wrapped
3: calling glGenVertexArrays through pyopengl causes a 1280 invalid
enumerant
4: which moves to the following glBindVertexArray call when you
call glGenVertexArrays through ctypes
5: glVertexAttribPointer will only accept a pointer for the last argument
not the integer value you pass when using it with GL_ARRAY_BUFFER bound.

I hope this aids in tracking down and resolving some of these problems.
And I am by no means a GL expert so it wouldn't surprise me at all if one
or more of these were my fault.

G

------------------------------------------------------------------------------
RSA(R) Conference 2012
Save $700 by Nov 18
Register now
http://p.sf.net/sfu/rsa-sfdev2dev1

_______________________________________________
PyOpenGL Homepage
http://pyopengl.sourceforge.net
_______________________________________________
PyOpenGL-Users mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/pyopengl-users

broke.py (text/x-python, 3.2 KB)

import OpenGL
OpenGL.ERROR_CHECKING = False
OpenGL.ERROR_ON_COPY = True
OpenGL.USE_ACCELERATE = True
OpenGL.FULL_LOGGING = False
OpenGL.FORWARD_COMPATIBLE_ONLY = True
from OpenGL.GL import *
from OpenGL.GLU import *
from OpenGL.GLUT import *

if True: # XXX1
    OpenGL.ERROR_CHECKING = True

import sys
import numpy
import ctypes

import logging
logging.basicConfig()

DLL = glGenVertexArrays.DLL

vertexData = numpy.array([
    0.75, 0.75, 0.0, 1.0,
    0.75, -0.75, 0.0, 1.0,
    -0.75, -0.75, 0.0, 1.0,
], numpy.float32)

vertexShader = """#version 330

layout(location = 0) in vec4 position;

void main()
{
    gl_Position = position;
}
"""

fragmentShader = """#version 330

out vec4 outputColor;

void main()
{
    outputColor = vec4(1, 1, 1, 1);
}
"""

def shader(src, shader_type):
    shader = glCreateShader(shader_type)
    glShaderSource(shader, src)
    glCompileShader(shader)
    if glGetShaderiv(shader, GL_COMPILE_STATUS) == GL_FALSE:
        msg = glGetShaderInfoLog(shader)
        assert False, msg
    return shader

def program(shaders):
    program = glCreateProgram()
    for shader in shaders:
        glAttachShader(program, shader)
    glLinkProgram(program)
    if glGetProgramiv(program, GL_LINK_STATUS) == GL_FALSE:
        msg = glGetProgramInfoLog(program)
        assert False, msg
    return program

def checkError():
    err = glGetError()
    if err != GL_NO_ERROR:
        msg = gluErrorString(err)
        print err, msg
        assert False

def main(argv):
    glutInit(argv)

    width = 500
    height = 500
    displayMode = GLUT_DOUBLE | GLUT_ALPHA | GLUT_DEPTH | GLUT_STENCIL

    glutInitDisplayMode(displayMode)
    glutInitContextVersion(3, 3)
    glutInitContextProfile(GLUT_CORE_PROFILE)
    glutInitContextFlags(GLUT_DEBUG | GLUT_FORWARD_COMPATIBLE)
    glutInitWindowSize(width, height)
    glutInitWindowPosition (300, 200)
    glutCreateWindow("main")

    glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_CONTINUE_EXECUTION)

    vert = shader(vertexShader, GL_VERTEX_SHADER)
    frag = shader(fragmentShader, GL_FRAGMENT_SHADER)
    prog = program([vert, frag])
    glUseProgram(prog)

    vbo = glGenBuffers(1)
    glBindBuffer(GL_ARRAY_BUFFER, vbo)
    glBufferData(GL_ARRAY_BUFFER, vertexData, GL_STATIC_DRAW)

    checkError()

    if True: # XXX2
        vao = glGenVertexArrays(1)
    elif True: # XXX3
        func = OpenGL.wrapper.wrapper(glGenVertexArrays).setOutput('arrays', lambda n: (n,), 'n',)
        vao = func(1)
    else:
        vao = GLuint()
        DLL.glGenVertexArrays(1, ctypes.byref(vao))

    checkError()

    if True: # XXX4
        glBindVertexArray(vao)
    else:
        DLL.glBindVertexArray(vao)
        assert glGetError() == GL_NO_ERROR

    checkError()

    glutDisplayFunc(display)
    glutReshapeFunc(reshape)
    glutMainLoop()

def display():
    glClearColor(0.0, 0.0, 0.0, 0.0)
    glClear(GL_COLOR_BUFFER_BIT)

    glEnableVertexAttribArray(0)

    if True: # XXX5
        glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, 0)
    else:
        DLL.glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, 0)

    glDrawArrays(GL_TRIANGLES, 0, 3)

    glutSwapBuffers()
    glutPostRedisplay()

def reshape(w, h):
    glViewport(0, 0, w, h)

main(sys.argv)