Ndtyjky

I'm having a weird issue with trying to move my working game code from Windows to Mac. I'm using SDL2 and OpenGL.

The game is a simple 2D game, basically only doing 2D quad/sprite rendering. The rendering architecture is simple. I'm using a single static Element Array Buffer that is prefilled at startup (6 indices, 4 vertices per quad), and every frame I push a new VBO with the sprite data (4 vertices per sprite, each containing xy position, color to modulate, and uv texture coordinates).

I'm doing this by calling glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY) at the start of the frame, push onto the given "array" the sprite data, and then glUnmapBuffer(GL_ARRAY_BUFFER) at the end before calling SDL_GL_SwapWindow.

All seems to work just fine on Windows, however when I tried compiling and running on a Mac, it complied just fine, but whenever I call glMapBuffer it returns NULL.

I tried looking for GL errors, but no luck. Calling glGetError() does not help as it returns 0.

It's possible that I have an issue somewhere and actually doing something wrong also on Windows (as the code is literally the same). Could be that the driver on Windows is just more lenient and "let's the error slide" but on my Mac it can't.

I'm literally stumped... I don't know where to go from here. I tried littering my code with glGetError() but could not find a non zero return from it anywhere I tried.

Here is the setup code if it helps:

    glGenVertexArrays(1, &overlay_vao);

    glBindVertexArray(overlay_vao);



    glGenBuffers(1, &overlay_vbo);

    glBindBuffer(GL_ARRAY_BUFFER, overlay_vbo);

    glBufferData(GL_ARRAY_BUFFER, MAX_OVERLAY_ELEMENTS * 4 * 8 * 4, 0, GL_STREAM_DRAW);

    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 8 * 4, 0);

    glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, 8 * 4, (GLvoid*)(2 * 4));

    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * 4, (GLvoid*)(6 * 4));

    glEnableVertexAttribArray(0);

    glEnableVertexAttribArray(1);

    glEnableVertexAttribArray(2);



    GLuint overlay_element_buffer;

    glGenBuffers(1, &overlay_element_buffer);

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, overlay_element_buffer);



    Uint8 *indicesBytes = AcquireTempMemory();

    Uint16 *indices = (Uint16*)indicesBytes;



    for (int i = 0; i < MAX_OVERLAY_ELEMENTS; i++)

    {

        indices[6 * i + 0] = 4 * i + 0;

        indices[6 * i + 1] = 4 * i + 1;

        indices[6 * i + 2] = 4 * i + 2;

        indices[6 * i + 3] = 4 * i + 0;

        indices[6 * i + 4] = 4 * i + 2;

        indices[6 * i + 5] = 4 * i + 3;



    }

    glBufferData(GL_ELEMENT_ARRAY_BUFFER, MAX_OVERLAY_ELEMENTS * 6 * 2, indicesBytes, GL_STATIC_DRAW);

AcquireTempMemory is basically not much more than a malloc, and I validated that it allocates fine, and the array is filled as expected (on both versions).

On start of every frame, I bind the VAO and the shader program (even though there is only one of each anyway), set some uniforms, and map the buffer:

    glEnable(GL_BLEND);

glUseProgram(renderState.overlayShaderProgram);

glBindVertexArray(renderState.overlayVao);

glUniform1f(renderState.xMultUniformLocation, 1.0f / renderState.aspectRatio);

glUniform1i(renderState.textureUniformLocation, 0);



renderState.overlayRects = 0;

renderState.overlayBuffer = glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);

Then once all sprites have been pushed:

    glUnmapBuffer(GL_ARRAY_BUFFER);

glDrawElements(GL_TRIANGLES, renderState.overlayRects * 6, GL_UNSIGNED_SHORT, (const GLvoid*)0);

(after that there is a call to SDL_GL_SwapWindow)

I'm not sure if it's relevant, but I'm getting the GL functions from SDL_GL_GetProcAddress like this:

    glMapBuffer = (glMapBuffer_TYPE)SDL_GL_GetProcAddress("glMapBuffer");

glUnmapBuffer = (glUnmapBuffer_TYPE)SDL_GL_GetProcAddress("glUnmapBuffer");

I'm really stuck... has anyone ever seen something like this, or can point me to something I'm doing wrong?

If you are using OpenGL 3.3, this means that your OSX version provides OGL function pointers on its own. No need to retrieve them by any GetProcAddress call.

Even worst, you are using the same names as the GL API ones: glMapBuffer instead of something near such as myglMapBuffer. And Apple tells against this:

From Apple doc

Note that each function pointer uses the prefix pf to distinguish it
from the function it points to. Although using this prefix is not a
requirement, it's best to avoid using the exact function names.

In order to use the same code for Windows, Linux and OSX I recommend to warp not OSX code with #ifndef like this:

#ifndef __APPLE__

  glMapBuffer = (glMapBuffer_TYPE)SDL_GL_GetProcAddress("glMapBuffer");

  glUnmapBuffer = (glUnmapBuffer_TYPE)SDL_GL_GetProcAddress("glUnmapBuffer");

  //etc

#endif

Also, you may need this Apple test (if SDL doesn't take it into account):

#ifdef __APPLE__

  #define GL_DO_NOT_WARN_IF_MULTI_GL_VERSION_HEADERS_INCLUDED

  #include <OpenGL/gl3.h>

#endif