glGenVertexArrays Mac OSX PyOpenGL

Question

I'm trying to run glGenVertexArrays on PyOpenGL on my Mac (10.11.5). It is not finding it.

The problem seems to be the version of OpenGL supported by my Mac (?). I've tried to research the issue but it seems that the documentation is written for either history nerds or trivia buffs, of which I am neither.

When I try to do this:

print("OpenGL: " + str(glGetString(GL_VERSION)))
print('glGenVertexArrays Available %s' % bool(glGenVertexArrays))
vao = glGenVertexArrays(1)

I get this:

OpenGL: 2.1 NVIDIA-10.10.10 310.42.25f01

glGenVertexArrays Available False

Traceback (most recent call last): File "_ctypes/callbacks.c", line 315, in 'calling callback function' File "draw.py", line 99, in doRedraw mesh.draw() File "/Users/carlos/vc/SimpleRender/Mesh.py", line 170, in draw vao = glGenVertexArrays(1) File "/Users/carlos/.virtualenvs/janus/lib/python2.7/site-packages/OpenGL/platform/baseplatform.py", line 407, in call self.name, self.name, OpenGL.error.NullFunctionError: Attempt to call an undefined function glGenVertexArrays, check for bool(glGenVertexArrays) before calling

Everybody online see here, or here seems to be running glGenVertexArrays without problem. This guy seems to run into my same problem but the solution suggested to him (adding GLUT_PROFILE_3_2_CORE is not defined in my PyOpenGL)

What am I doing wrong?

EDIT:

I've tried pyglet and PyQt5 (running under python3) and it always comes down to missing glGenVertexArrays.

It seems (a lot of misinformation online about this) that what I need to do is set up the Core Profile. How do I do that? If I drop the Python requirement would it be easier? Consider that I'm not chump and that I've troubleshooted my problem significantly before posting it here.

I have:

I'm running on the bare metal, not virtualization, no VM, no docker.

The output for glxinfo is:

name of display: /private/tmp/com.apple.launchd.RUemSPHKIt/org.macosforge.xquartz:0
display: /private/tmp/com.apple.launchd.RUemSPHKIt/org.macosforge.xquartz:0  screen: 0
direct rendering: Yes
server glx vendor string: SGI
server glx version string: 1.4
server glx extensions:
    GLX_ARB_multisample, GLX_EXT_import_context, GLX_EXT_visual_info,
    GLX_EXT_visual_rating, GLX_OML_swap_method, GLX_SGIS_multisample,
    GLX_SGIX_fbconfig
client glx vendor string: Mesa Project and SGI
client glx version string: 1.4
client glx extensions:
    GLX_ARB_create_context, GLX_ARB_create_context_profile,
    GLX_ARB_create_context_robustness, GLX_ARB_fbconfig_float,
    GLX_ARB_framebuffer_sRGB, GLX_ARB_get_proc_address, GLX_ARB_multisample,
    GLX_EXT_buffer_age, GLX_EXT_create_context_es2_profile,
    GLX_EXT_create_context_es_profile, GLX_EXT_fbconfig_packed_float,
    GLX_EXT_framebuffer_sRGB, GLX_EXT_import_context,
    GLX_EXT_texture_from_pixmap, GLX_EXT_visual_info, GLX_EXT_visual_rating,
    GLX_INTEL_swap_event, GLX_MESA_copy_sub_buffer,
    GLX_MESA_multithread_makecurrent, GLX_MESA_query_renderer,
    GLX_MESA_swap_control, GLX_OML_swap_method, GLX_OML_sync_control,
    GLX_SGIS_multisample, GLX_SGIX_fbconfig, GLX_SGIX_pbuffer,
    GLX_SGIX_visual_select_group, GLX_SGI_make_current_read,
    GLX_SGI_swap_control, GLX_SGI_video_sync
GLX version: 1.4
GLX extensions:
    GLX_ARB_get_proc_address, GLX_ARB_multisample, GLX_EXT_import_context,
    GLX_EXT_visual_info, GLX_EXT_visual_rating,
    GLX_MESA_multithread_makecurrent, GLX_OML_swap_method,
    GLX_SGIS_multisample, GLX_SGIX_fbconfig
OpenGL vendor string: NVIDIA Corporation
OpenGL renderer string: NVIDIA GeForce GT 750M OpenGL Engine
OpenGL version string: 2.1 NVIDIA-10.10.10 310.42.25f01
OpenGL shading language version string: 1.20
OpenGL extensions:
    GL_APPLE_aux_depth_stencil, GL_APPLE_client_storage,
    GL_APPLE_element_array, GL_APPLE_fence, GL_APPLE_float_pixels,
    GL_APPLE_flush_buffer_range, GL_APPLE_flush_render,
    GL_APPLE_object_purgeable, GL_APPLE_packed_pixels, GL_APPLE_pixel_buffer,
    GL_APPLE_rgb_422, GL_APPLE_row_bytes, GL_APPLE_specular_vector,
    GL_APPLE_texture_range, GL_APPLE_transform_hint,
    GL_APPLE_vertex_array_object, GL_APPLE_vertex_array_range,
    GL_APPLE_vertex_point_size, GL_APPLE_vertex_program_evaluators,
    GL_APPLE_ycbcr_422, GL_ARB_color_buffer_float, GL_ARB_depth_buffer_float,
    GL_ARB_depth_clamp, GL_ARB_depth_texture, GL_ARB_draw_buffers,
    GL_ARB_draw_elements_base_vertex, GL_ARB_draw_instanced,
    GL_ARB_fragment_program, GL_ARB_fragment_program_shadow,
    GL_ARB_fragment_shader, GL_ARB_framebuffer_object,
    GL_ARB_framebuffer_sRGB, GL_ARB_half_float_pixel,
    GL_ARB_half_float_vertex, GL_ARB_imaging, GL_ARB_instanced_arrays,
    GL_ARB_multisample, GL_ARB_multitexture, GL_ARB_occlusion_query,
    GL_ARB_pixel_buffer_object, GL_ARB_point_parameters, GL_ARB_point_sprite,
    GL_ARB_provoking_vertex, GL_ARB_seamless_cube_map, GL_ARB_shader_objects,
    GL_ARB_shader_texture_lod, GL_ARB_shading_language_100, GL_ARB_shadow,
    GL_ARB_sync, GL_ARB_texture_border_clamp, GL_ARB_texture_compression,
    GL_ARB_texture_compression_rgtc, GL_ARB_texture_cube_map,
    GL_ARB_texture_env_add, GL_ARB_texture_env_combine,
    GL_ARB_texture_env_crossbar, GL_ARB_texture_env_dot3,
    GL_ARB_texture_float, GL_ARB_texture_mirrored_repeat,
    GL_ARB_texture_non_power_of_two, GL_ARB_texture_rectangle,
    GL_ARB_texture_rg, GL_ARB_transpose_matrix, GL_ARB_vertex_array_bgra,
    GL_ARB_vertex_blend, GL_ARB_vertex_buffer_object, GL_ARB_vertex_program,
    GL_ARB_vertex_shader, GL_ARB_window_pos, GL_ATI_separate_stencil,
    GL_ATI_texture_env_combine3, GL_ATI_texture_float,
    GL_ATI_texture_mirror_once, GL_EXT_abgr, GL_EXT_bgra,
    GL_EXT_bindable_uniform, GL_EXT_blend_color,
    GL_EXT_blend_equation_separate, GL_EXT_blend_func_separate,
    GL_EXT_blend_minmax, GL_EXT_blend_subtract, GL_EXT_clip_volume_hint,
    GL_EXT_debug_label, GL_EXT_debug_marker, GL_EXT_depth_bounds_test,
    GL_EXT_draw_buffers2, GL_EXT_draw_range_elements, GL_EXT_fog_coord,
    GL_EXT_framebuffer_blit, GL_EXT_framebuffer_multisample,
    GL_EXT_framebuffer_multisample_blit_scaled, GL_EXT_framebuffer_object,
    GL_EXT_framebuffer_sRGB, GL_EXT_geometry_shader4,
    GL_EXT_gpu_program_parameters, GL_EXT_gpu_shader4,
    GL_EXT_multi_draw_arrays, GL_EXT_packed_depth_stencil,
    GL_EXT_packed_float, GL_EXT_provoking_vertex, GL_EXT_rescale_normal,
    GL_EXT_secondary_color, GL_EXT_separate_specular_color,
    GL_EXT_shadow_funcs, GL_EXT_stencil_two_side, GL_EXT_stencil_wrap,
    GL_EXT_texture_array, GL_EXT_texture_compression_dxt1,
    GL_EXT_texture_compression_s3tc, GL_EXT_texture_env_add,
    GL_EXT_texture_filter_anisotropic, GL_EXT_texture_integer,
    GL_EXT_texture_lod_bias, GL_EXT_texture_mirror_clamp,
    GL_EXT_texture_rectangle, GL_EXT_texture_sRGB, GL_EXT_texture_sRGB_decode,
    GL_EXT_texture_shared_exponent, GL_EXT_timer_query,
    GL_EXT_transform_feedback, GL_EXT_vertex_array_bgra,
    GL_IBM_rasterpos_clip, GL_NV_blend_square, GL_NV_conditional_render,
    GL_NV_depth_clamp, GL_NV_fog_distance, GL_NV_fragment_program2,
    GL_NV_fragment_program_option, GL_NV_light_max_exponent,
    GL_NV_multisample_filter_hint, GL_NV_point_sprite,
    GL_NV_texgen_reflection, GL_NV_texture_barrier,
    GL_NV_vertex_program2_option, GL_NV_vertex_program3,
    GL_SGIS_generate_mipmap, GL_SGIS_texture_edge_clamp, GL_SGIS_texture_lod

128 GLX Visuals
...

Answer 1

First of all, I'd suggest each time you use an Opengl function you check which opengl version is required to run it with not problems, for instance, if we look at glGenVertexArrays we'll see you need Opengl >= 3.0. Now, the reason you're getting 2.1 version when doing glGetString(GL_VERSION) is either because you got a really old card (unlikely) or because you haven't enabled the Opengl core profile. Once you do that you should see the right Opengl version and running modern Opengl functions such as the one you're asking for.

In some cases like using pyqt opengl widgets, the context setup will be done behind the curtains for you... Or as you're mentioning if you're using glut there will be a feature to do so.

One way it'd be enabling the core profile manually, which can be tidious if you're a beginner with opengl, if you just want to use opengl without too much hazzle I'd recommend to use something on top of pyopengl, such as pyqt, pyglet, glut, pygame... There are tons of wrappers where you won't find yourself making the manual setup. Below you'll find a simple example which uses QGlWidget which comes with PyQt5 (pip install PyQt5) which should work out of the box:

import textwrap
import sys
import time
import ctypes
from array import array

from PyQt5 import QtWidgets
from PyQt5.QtOpenGL import QGLWidget
from PyQt5.QtWidgets import QApplication

from OpenGL.GL import *
from OpenGL.GLU import *


class FooOpengl(QGLWidget):

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)

        # Test to show how at this point Opengl Context setup hasn't been done
        # and therefore will crash
        print('{:*^80}'.format('Opengl Context not ready'))
        try:
            print(self._opengl_info())
        except Exception as e:
            print(e)

        self.start_time = time.clock()
        self.startTimer(0)

    def initializeGL(self):
        # Test to show how at this point Opengl Context is ready to go
        print('{:*^80}'.format('Opengl Context ready'))
        print(self._opengl_info())

        # Shaders: Trivial program
        vs_source = textwrap.dedent("""
            #version 330
            in vec3 position;
            void main()
            {
               gl_Position = vec4(position, 1.0);
            }\
        """)

        fs_source = textwrap.dedent("""
            #version 330
            void main()
            {
               gl_FragColor = vec4(1.0f, 1.0f, 1.0f, 1.0f);
            }\
        """)

        vs = glCreateShader(GL_VERTEX_SHADER)
        glShaderSource(vs, vs_source)
        glCompileShader(vs)
        fs = glCreateShader(GL_FRAGMENT_SHADER)
        glShaderSource(fs, fs_source)
        glCompileShader(fs)

        self.program = glCreateProgram()
        glAttachShader(self.program, fs)
        glAttachShader(self.program, vs)
        glLinkProgram(self.program)

        vertices = [
            0.0, 0.5, 0.0,
            0.5, -0.5, 0.0,
            -0.5, -0.5, 0.0
        ]

        vbo = glGenBuffers(1)
        glBindBuffer(GL_ARRAY_BUFFER, vbo)

        self.vao = glGenVertexArrays(1)
        glBindVertexArray(self.vao)
        position = glGetAttribLocation(self.program, 'position')
        glEnableVertexAttribArray(position)
        glVertexAttribPointer(
            position, 3, GL_FLOAT, False, 0, ctypes.c_void_p(0))

        glBufferData(
            GL_ARRAY_BUFFER, array("f", vertices).tostring(), GL_STATIC_DRAW)
        glBindVertexArray(0)
        glDisableVertexAttribArray(position)
        glBindBuffer(GL_ARRAY_BUFFER, 0)

    def timerEvent(self, event):
        elapsed = time.clock() - self.start_time
        self.repaint()

    def paintGL(self):
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
        glLoadIdentity()
        glUseProgram(self.program)

        glBindVertexArray(self.vao)
        glDrawArrays(GL_TRIANGLES, 0, 3)
        glBindVertexArray(0)

        glUseProgram(0)

    def _opengl_info(self):
        return textwrap.dedent("""\
            Vendor: {0}
            Renderer: {1}
            OpenGL Version: {2}
            Shader Version: {3}
            Num Extensions: {4}
            Extensions: {5}
        """).format(
            glGetString(GL_VENDOR).decode("utf-8"),
            glGetString(GL_RENDERER).decode("utf-8"),
            glGetString(GL_VERSION).decode("utf-8"),
            glGetString(GL_SHADING_LANGUAGE_VERSION).decode("utf-8"),
            glGetIntegerv(GL_NUM_EXTENSIONS),
            glGetString(GL_EXTENSIONS)
        )

if __name__ == "__main__":
    app = QtWidgets.QApplication(sys.argv)
    ex = FooOpengl()
    ex.show()

    sys.exit(app.exec_())

It's just a simple test which shows you what happens when the context is ready and when is not, also it gives you some extra candies about the usage of vbo+vao+shaders, it should give you something similar to this:

This should be alright to get you started... As I've said, there are tons of wrappers on top of opengl, if not pyglet, pygame is a very famous one in the python community and it got tons of cool features.