Replacing glXSwapBuffers with eglSwapBuffers

[berylline]

This issue is for figuring this out:

glXSwapBuffers --> eglSwapBuffers

This is tied to #15, by the way.

TBD.

[berylline]

For glXSwapBuffers:

https://registry.khronos.org/OpenGL-Refpages/gl2.1/xhtml/glXSwapBuffers.xml

For its C definition:

void glXSwapBuffers(	Display * dpy,
 	GLXDrawable drawable);

Note: In the realm of GLX, GLXPixmap, GLXWindow, GLXPbuffer and Window(A "window" in X11 and specifically, XLib's definition of one) are all GLXDrawables, apparently, according to the GLX 1.4 specification in Chapter 2(GLX Operation), 2.1(Rendering Contexts and Drawing Surfaces):

"For backwards compatibility with GLX versions 1.2 and earlier, a rendering
context can also be used to render into a Window. Thus, a GLXDrawable is the
union {GLXWindow, GLXPixmap, GLXPbuffer, Window}."

https://registry.khronos.org/OpenGL/specs/gl/glx1.4.pdf

As well as this comment:

"GLX 1.3 extended the definition of GLXDrawable as { GLXWindow, GLXPixmap, GLXPbuffer, Window }. So that you can see a new item GLXPbuffer, which was an attempt to improve off-screen rendering before Frame Buffer Objects (FBO) was introduced in OpenGL itself. Unlike pixmaps and windows, GLXPbuffer is created from scratch and has no relation in X. There is also a new GLXWindow with the note:

For backwards compatibility with GLX versions 1.2 and earlier, a rendering context can also be used to render into a Window.

So that GLXWindow looks more like an attempt to unify API (and internal logic) across all GLXDrawable, rather than a tool which fixes something, as it doesn't extend capabilities of X Window from a first glance."

https://stackoverflow.com/a/60797478

[berylline]

For eglSwapBuffers:

https://registry.khronos.org/EGL/sdk/docs/man/html/eglSwapBuffers.xhtml

For its C definition:

EGLBoolean eglSwapBuffers(	EGLDisplay display,
 	EGLSurface surface);

According to the example code for EGL_EXT_platform_x11, it definitely looks like I can use EGLSurfaces as drop-in replacements for all GLXDrawables for X Windows and Pixmaps(besides #15 (comment) also being the rationale for this besides also while using XLib, of course) as demonstrated by these structs here:

struct my_window {
        struct my_config config;
        Window x11;
        EGLSurface egl;
    };

    struct my_pixmap {
        struct my_config config;
        Pixmap x11;
        EGLSurface egl;
    };

And this is the code demonstrating that with Windows(with XLib):

static struct my_window
    get_window(struct my_config config)
    {
        XSetWindowAttributes attr;
        unsigned long mask;

        struct my_window window = {
            .config = config,
        };

        attr.colormap = config.colormap;
        mask = CWColormap;

        window.x11 = XCreateWindow(config.dpy.x11,
                                   DefaultRootWindow(config.dpy.x11), // parent
                                   0, 0, // x, y
                                   256, 256, // width, height
                                   0, // border_width
                                   config.x11->depth,
                                   InputOutput, // class
                                   config.x11->visual,
                                   mask, // valuemask
                                   &attr); // attributes
        if (!window.x11) {
            abort();
        }

    #ifdef USE_EGL_EXT_PLATFORM_X11
        window.egl = eglCreatePlatformWindowSurfaceEXT(config.dpy.egl,
                                                       config.egl,
                                                       &window.x11,
                                                       NULL);
    #else
        window.egl = eglCreateWindowSurface(config.dpy.egl,
                                            config.egl,
                                            window.x11,
                                            NULL);
    #endif

        if (window.egl == EGL_NO_SURFACE) {
            abort();
        }

        return window;
    }

And for Pixmaps(also with XLib):

static struct my_pixmap
    get_pixmap(struct my_config config)
    {
        struct my_pixmap pixmap = {
            .config = config,
        };

        pixmap.x11 = XCreatePixmap(config.dpy.x11,
                                   DefaultRootWindow(config.dpy.x11),
                                   256, 256, // width, height
                                   config.x11->depth);
        if (!pixmap.x11) {
            abort();
        }

    #ifdef USE_EGL_EXT_PLATFORM_X11
        pixmap.egl = eglCreatePlatformPixmapSurfaceEXT(config.dpy.egl,
                                                       config.egl,
                                                       &pixmap.x11,
                                                       NULL);
    #else
        pixmap.egl = eglCreatePixmapSurface(config.dpy.egl,
                                            config.egl,
                                            pixmap.x11,
                                            NULL);
    #endif

        if (pixmap.egl == EGL_NO_SURFACE) {
            abort();
        }

        return pixmap;
    }

For the equivalent example code targeting XCB(EGL_EXT_platform_xcb), everything is as follows(important for #2, specifically #2 (comment)):

Some notes:

xcb_window_t takes the place of Window.

xcb_pixmap_t takes the place of Pixmap.

For the structs:

struct my_window {
        struct my_config config;
        xcb_window_t x11;
        EGLSurface egl;
    };

    struct my_pixmap {
        struct my_config config;
        xcb_pixmap_t x11;
        EGLSurface egl;
    };

For xcb_window_ts:

static struct my_window get_window(struct my_config config) {
        xcb_generic_error_t *e;

        struct my_window window = {
            .config = config,
        };

        window.x11 = xcb_generate_id(config.dpy.x11);
        e = xcb_request_check(
            config.dpy.x11,
            xcb_create_window_checked(config.dpy.x11,            // connection
                                      XCB_COPY_FROM_PARENT,      // depth
                                      window.x11,                // window id
                                      config.dpy.root_of_screen, // root
                                      0, 0,                      // x, y
                                      256, 256,                  // width, height
                                      0,                         // border_width
                                      XCB_WINDOW_CLASS_INPUT_OUTPUT, // class
                                      config.visualid,               // visual
                                      XCB_CW_COLORMAP,               // mask
                                      (const int[]){
                                          config.colormap,
                                          XCB_NONE,
                                      }));
        if (e) {
            abort();
        }

        window.egl = eglCreatePlatformWindowSurfaceEXT(config.dpy.egl, config.egl,
                                                       &window.x11, NULL);

        if (window.egl == EGL_NO_SURFACE) {
            abort();
        }

        return window;
    }

For xcb_pixmap_ts:

static struct my_pixmap get_pixmap(struct my_config config) {
        struct my_pixmap pixmap = {
            .config = config,
        };

        pixmap.x11 = xcb_generate_id(config.dpy.x11);
        if (xcb_request_check(
                config.dpy.x11,
                xcb_create_pixmap(config.dpy.x11, config.depth, pixmap.x11,
                                  config.dpy.root_of_screen, 256, 256))) {
            abort();
        }

        pixmap.egl = eglCreatePlatformPixmapSurfaceEXT(config.dpy.egl, config.egl,
                                                       &pixmap.x11, NULL);

        if (pixmap.egl == EGL_NO_SURFACE) {
            abort();
        }

        return pixmap;
    }