We are currently migrating Bugzilla to GitHub issues.
Any changes made to the bug tracker now will be lost, so please do not post new bugs or make changes to them.
When we're done, all bug URLs will redirect to their equivalent location on the new bug tracker.

Standalone code to reproduce the FBO 0 incomplete issue

sdltest2.c (text/x-csrc), 11.02 KB, created by kagekirin on 2021-02-03 03:33:56 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: kagekirin

Created: 2021-02-03 03:33:56 UTC

Size: 11.02 KB

patch

obsolete

>#include <SDL2/SDL.h>
>#define GLEW_STATIC
>#include <GL/glew.h>
>#include <assert.h>
>#include <stdbool.h>
>#include <stdint.h>
>#include <stdio.h>
>
>//-----------------------------------------------------------------------------
>/// config defines
>
>#define _DEBUG_PRINT
>#define _SAFE_OPENGL
>#define USE_GLEW
>
>//-----------------------------------------------------------------------------
>/// macros
>
>#define ASSERT(x) assert(x)
>
>#define PUSH_DEBUG_GROUP(id, msg)                                                        \
>    {                                                                                    \
>        if (glPushDebugGroup)                                                            \
>        {                                                                                \
>            SAFEGL(glPushDebugGroup(GL_DEBUG_SOURCE_APPLICATION, id, sizeof(msg), msg)); \
>        }                                                                                \
>    }
>
>#define POP_DEBUG_GROUP()              \
>    {                                  \
>        if (glPopDebugGroup)           \
>        {                              \
>            SAFEGL(glPopDebugGroup()); \
>        }                              \
>    }
>
>void safegl_print(int err, char* call, char* file, int line);
>
>#ifdef _SAFE_OPENGL
>#define SAFEGL(call)                                      \
>    (call);                                               \
>    {                                                     \
>        GLenum err = glGetError();                        \
>        if (err != GL_NO_ERROR)                           \
>        {                                                 \
>            safegl_print(err, #call, __FILE__, __LINE__); \
>        }                                                 \
>    }
>#else
>#define SAFEGL(call) (call);
>#endif
>
>#ifdef _DEBUG_PRINT
>#define DEBUG_PRINT(fmt, ...) printf(fmt, __VA_ARGS__)
>#else
>#define DEBUG_PRINT(fmt, ...)
>#endif
>
>//-----------------------------------------------------------------------------
>/// typedefs
>
>typedef uint8_t u8;
>typedef int8_t i8;
>typedef uint16_t u16;
>typedef int16_t i16;
>typedef int32_t u32;
>typedef uint32_t i32;
>
>typedef GLboolean bvec2_a[2];
>typedef GLboolean bvec3_a[3];
>typedef GLboolean bvec4_a[4];
>typedef GLint ivec2_a[2];
>typedef GLint ivec3_a[3];
>typedef GLint ivec4_a[4];
>typedef GLfloat fvec2_a[2];
>typedef GLfloat fvec3_a[3];
>typedef GLfloat fvec4_a[4];
>typedef fvec4_a fmat4_a[4];
>
>typedef struct bvec2_t
>{
>    GLboolean x, y;
>} bvec2_t;
>typedef struct bvec3_t
>{
>    GLboolean x, y, z;
>} bvec3_t;
>typedef struct bvec4_t
>{
>    GLboolean x, y, z, w;
>} bvec4_t;
>typedef struct ivec2_t
>{
>    GLint x, y;
>} ivec2_t;
>typedef struct ivec3_t
>{
>    GLint x, y, z;
>} ivec3_t;
>typedef struct ivec4_t
>{
>    GLint x, y, z, w;
>} ivec4_t;
>typedef struct fvec2_t
>{
>    GLfloat x, y;
>} fvec2_t;
>typedef struct fvec3_t
>{
>    GLfloat x, y, z;
>} fvec3_t;
>typedef struct fvec4_t
>{
>    GLfloat x, y, z, w;
>} fvec4_t;
>typedef struct fmat4_t
>{
>    fvec4_t r0, r1, r2, r3;
>} fmat4_t;
>
>//-----------------------------------------------------------------------------
>/// globals
>
>SDL_Window* s_window = NULL;
>SDL_Surface* s_screen = NULL;
>SDL_GLContext s_glcontext = 0;
>
>//-----------------------------------------------------------------------------
>/// forward declarations
>
>int initGraphics();
>void exitGraphics();
>int initRenderer(u32 width, u32 height);
>void exitRenderer();
>void runMainLoop();
>int mainLoopIteration();
>void onFrameRendered();
>
>bool isRenderTargetComplete(GLuint fbo);
>GLuint getCurrentRenderTarget();
>void initDefaultRenderTarget();
>void restoreDefaultRenderTarget();
>void pushRenderTarget(GLuint fbo);
>void popRenderTarget();
>
>//-----------------------------------------------------------------------------
>/// main
>
>int main(int argc, char* argv[])
>{
>    initGraphics();
>    runMainLoop();
>    exitGraphics();
>
>    return 0;
>}
>
>void runMainLoop()
>{
>    int status = 0;
>    do
>    {
>        status = mainLoopIteration();
>    } while (status > 0);
>}
>
>int mainLoopIteration()
>{
>    static int internalState = 0;
>
>    if (internalState == 0)
>    {
>        int err = initRenderer(640, 480);
>        if (err) return 0;
>        internalState++;
>    }
>
>    onFrameRendered();
>
>    SDL_Event event;
>    while (SDL_PollEvent(&event))
>    {
>        switch (event.type)
>        {
>            case SDL_QUIT:
>                return 0;
>                break;
>            case SDL_KEYDOWN:
>                return 0;
>                break;
>        }
>    }
>
>    return internalState;
>}
>
>//-----------------------------------------------------------------------------
>/// implementations
>
>int initGraphics()
>{
>    int initOk = SDL_Init(SDL_INIT_VIDEO);
>    if (initOk < 0)
>    {
>        DEBUG_PRINT("SDL2 SDL_Init failed: %s\n", SDL_GetError());
>    }
>    ASSERT(initOk >= 0);
>
>    SDL_version sdlVersion;
>    SDL_GetVersion(&sdlVersion);
>    DEBUG_PRINT("using SDL version %i.%i.%i, rev. %s [%i]\n", sdlVersion.major, sdlVersion.minor, sdlVersion.patch,
>                SDL_GetRevision(), SDL_GetRevisionNumber());
>
>    int loadOk = SDL_GL_LoadLibrary(NULL);  // Default OpenGL is fine.
>    if (loadOk < 0)
>    {
>        DEBUG_PRINT("SDL2 SDL_GL_LoadLibrary failed: %s\n", SDL_GetError());
>    }
>    DEBUG_PRINT("SDL2 video driver: %s\n", SDL_GetCurrentVideoDriver());
>    ASSERT(loadOk >= 0);
>    // TODO: SDL_GL_SetAttribute if needed
>    SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL, 1);
>    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
>    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
>    SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG);
>    SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_DEBUG_FLAG);
>    SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
>    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
>    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
>    SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 10);
>    SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 10);
>    SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 10);
>    SDL_GL_SetSwapInterval(1);  // Use VSYNC
>    return 0;
>}
>
>void exitGraphics()
>{
>    SDL_GL_DeleteContext(s_glcontext);
>    SDL_DestroyWindow(s_window);
>    SDL_Quit();
>}
>
>int initRenderer(u32 width, u32 height)
>{
>    // create window
>    if (!s_window)
>    {
>        s_window =
>            SDL_CreateWindow("SDL2 TEST", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, width, height,
>                             SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE | SDL_WINDOW_BORDERLESS);
>    }
>    if (!s_window)
>    {
>        DEBUG_PRINT("SDL2 SDL_CreateWindow failed: %s\n", SDL_GetError());
>    }
>    ASSERT(s_window);
>
>    // create GL context
>    if (!s_glcontext)
>    {
>        s_glcontext = SDL_GL_CreateContext(s_window);
>        SDL_GL_MakeCurrent(s_window, s_glcontext);
>    }
>    if (s_glcontext)
>    {
>        DEBUG_PRINT("GL base context GL version: %s\n", glGetString(GL_VERSION));
>        DEBUG_PRINT("GL base context GLSL version: %s\n", glGetString(GL_SHADING_LANGUAGE_VERSION));
>        DEBUG_PRINT("GL base context GL vendor: %s\n", glGetString(GL_VENDOR));
>        DEBUG_PRINT("GL base context GL renderer: %s\n", glGetString(GL_RENDERER));
>    }
>    else
>    {
>        DEBUG_PRINT("SDL2 SDL_GL_CreateContext failed: %s\n", SDL_GetError());
>    }
>    ASSERT(s_glcontext);
>
>    // get window surface
>    if (!s_screen)
>    {
>        s_screen = SDL_GetWindowSurface(s_window);
>    }
>    ASSERT(s_screen);
>
>    SDL_GL_MakeCurrent(s_window, s_glcontext);
>
>#ifdef USE_GLEW
>    glewExperimental = GL_TRUE;
>    GLenum glewErr = glewInit();
>    if (glewErr != GLEW_OK)
>    {
>        DEBUG_PRINT("GLEW glewInit failed: %s\n", glewGetErrorString(glewErr));
>    }
>    ASSERT(glewErr == GLEW_OK);
>
>    DEBUG_PRINT("GLEW advanced context GL version: %s\n", glGetString(GL_VERSION));
>    DEBUG_PRINT("GLEW advanced context GLSL version: %s\n", glGetString(GL_SHADING_LANGUAGE_VERSION));
>    DEBUG_PRINT("GLEW advanced context GL vendor: %s\n", glGetString(GL_VENDOR));
>    DEBUG_PRINT("GLEW advanced context GL renderer: %s\n", glGetString(GL_RENDERER));
>#endif  // USE_GLEW
>
>    PUSH_DEBUG_GROUP(__LINE__, __FUNCTION__);
>    initDefaultRenderTarget();
>    restoreDefaultRenderTarget();
>
>    POP_DEBUG_GROUP();
>
>    return 0;
>}
>
>void exitRenderer()
>{
>    PUSH_DEBUG_GROUP(__LINE__, __FUNCTION__);
>
>    POP_DEBUG_GROUP();
>}
>
>void onFrameRendered()
>{
>    PUSH_DEBUG_GROUP(__LINE__, __FUNCTION__);
>    SDL_GL_SwapWindow(s_window);
>    initDefaultRenderTarget();
>    restoreDefaultRenderTarget();
>    ASSERT(isRenderTargetComplete(getCurrentRenderTarget()));
>    POP_DEBUG_GROUP();
>}
>//-----------------------------------------------------------------------------
>/// render target
>
>bool isRenderTargetComplete(GLuint fbo)
>{
>    pushRenderTarget(fbo);
>
>    int status = SAFEGL(glCheckFramebufferStatus(GL_FRAMEBUFFER));
>    if (status != GL_FRAMEBUFFER_COMPLETE)
>    {
>        DEBUG_PRINT("unexpected fbo status: 0x%x\n", status);
>    }
>
>    popRenderTarget();
>    return status == GL_FRAMEBUFFER_COMPLETE;
>}
>
>GLuint getCurrentRenderTarget()
>{
>    GLuint fbo = 0;
>    SAFEGL(glGetIntegerv(GL_FRAMEBUFFER_BINDING, &fbo));
>    return fbo;
>}
>
>enum
>{
>    FBO_STACK_SIZE = 256
>};
>static GLuint fboStack[FBO_STACK_SIZE];
>u16 curStack = 0;  // we wouldn't want it to overflow and loop in [0,255] right?
>static GLuint defaultFbo = 0;
>
>void initDefaultRenderTarget()
>{
>    PUSH_DEBUG_GROUP(__LINE__, __FUNCTION__);
>    SAFEGL(glGetIntegerv(GL_FRAMEBUFFER_BINDING, &defaultFbo));
>    DEBUG_PRINT("Default FBO bound to: %i\n", defaultFbo);
>    fboStack[0] = defaultFbo;
>    POP_DEBUG_GROUP();
>}
>
>void restoreDefaultRenderTarget()
>{
>    if (getCurrentRenderTarget() != defaultFbo)
>    {
>        SAFEGL(glBindFramebuffer(GL_FRAMEBUFFER, defaultFbo));
>    }
>}
>
>void pushRenderTarget(GLuint fbo)
>{
>    ASSERT(curStack < FBO_STACK_SIZE);
>    curStack++;
>    fboStack[curStack] = fbo;
>    if (getCurrentRenderTarget() != fbo)
>    {
>        SAFEGL(glBindFramebuffer(GL_FRAMEBUFFER, fbo));
>    }
>}
>
>void popRenderTarget()
>{
>    curStack--;
>    if (getCurrentRenderTarget() != fboStack[curStack])
>    {
>        SAFEGL(glBindFramebuffer(GL_FRAMEBUFFER, fboStack[curStack]));
>    }
>}
>
>//-----------------------------------------------------------------------------
>/// error handling
>
>static const char* getErrorDesc(int err)
>{
>    switch (err)
>    {
>        case GL_INVALID_ENUM:
>            return "GL_INVALID_ENUM";
>        case GL_INVALID_VALUE:
>            return "GL_INVALID_VALUE";
>        case GL_INVALID_OPERATION:
>            return "GL_INVALID_OPERATION";
>        case GL_STACK_OVERFLOW:
>            return "GL_STACK_OVERFLOW";
>        case GL_STACK_UNDERFLOW:
>            return "GL_STACK_UNDERFLOW";
>        case GL_OUT_OF_MEMORY:
>            return "GL_OUT_OF_MEMORY";
>        case GL_INVALID_FRAMEBUFFER_OPERATION:
>            return "GL_INVALID_FRAMEBUFFER_OPERATION";
>        case GL_CONTEXT_LOST:
>            return "GL_CONTEXT_LOST";
>    }
>    return "unknown error";
>}
>
>void safegl_print(int err, char* call, char* file, int line)
>{
>    fprintf(stdout, "GL ERROR: 0x%x (%s) at '%s' %s:%d\n", err, getErrorDesc(err), call, file, line);
>}
>
>//-----------------------------------------------------------------------------

Actions: View

Attachments on bug 5504: 4752

We are currently migrating Bugzilla to GitHub issues.Any changes made to the bug tracker now will be lost, so please do not post new bugs or make changes to them.When we're done, all bug URLs will redirect to their equivalent location on the new bug tracker.

We are currently migrating Bugzilla to GitHub issues.
Any changes made to the bug tracker now will be lost, so please do not post new bugs or make changes to them.
When we're done, all bug URLs will redirect to their equivalent location on the new bug tracker.