diff options
Diffstat (limited to 'src/libui_sdl/libui/unix/gl.c')
| -rw-r--r-- | src/libui_sdl/libui/unix/gl.c | 391 |
1 files changed, 387 insertions, 4 deletions
diff --git a/src/libui_sdl/libui/unix/gl.c b/src/libui_sdl/libui/unix/gl.c index da41437..3504d3a 100644 --- a/src/libui_sdl/libui/unix/gl.c +++ b/src/libui_sdl/libui/unix/gl.c @@ -1,6 +1,12 @@ // 26 may 2019 #include "uipriv_unix.h" +#include <X11/Xlib.h> +#include <GL/gl.h> +#include <GL/glx.h> + +extern GThread* gtkthread; + /* *(melonDS:17013): Gtk-CRITICAL **: 00:28:09.095: gtk_gl_area_set_required_version: assertion 'GTK_IS_GL_AREA (area)' failed @@ -9,32 +15,409 @@ struct uiGLContext { GtkGLArea *gla; + GtkWidget* widget; + GdkWindow* window; GdkGLContext *gctx; + + Display* xdisp; + GLXPixmap glxpm; + GLXContext glxctx; int vermaj, vermin; + + int width, height; + int scale; + GLuint renderbuffer[2]; + GLuint framebuffer; }; +static PFNGLGENRENDERBUFFERSPROC _glGenRenderbuffers; +static PFNGLDELETERENDERBUFFERSPROC _glDeleteRenderbuffers; +static PFNGLBINDRENDERBUFFERPROC _glBindRenderbuffer; +static PFNGLRENDERBUFFERSTORAGEPROC _glRenderbufferStorage; +static PFNGLGETRENDERBUFFERPARAMETERIVPROC _glGetRenderbufferParameteriv; + +static PFNGLGENRENDERBUFFERSPROC _glGenFramebuffers; +static PFNGLDELETERENDERBUFFERSPROC _glDeleteFramebuffers; +static PFNGLBINDRENDERBUFFERPROC _glBindFramebuffer; +static PFNGLFRAMEBUFFERTEXTUREPROC _glFramebufferTexture; +static PFNGLFRAMEBUFFERRENDERBUFFERPROC _glFramebufferRenderbuffer; +static PFNGLCHECKFRAMEBUFFERSTATUSPROC _glCheckFramebufferStatus; + +static int _procsLoaded = 0; + +static void _loadGLProcs() +{ + if (_procsLoaded) return; + + _glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC)uiGLGetProcAddress("glGenRenderbuffers"); + _glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC)uiGLGetProcAddress("glDeleteRenderbuffers"); + _glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC)uiGLGetProcAddress("glBindRenderbuffer"); + _glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC)uiGLGetProcAddress("glRenderbufferStorage"); + _glGetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC)uiGLGetProcAddress("glGetRenderbufferParameteriv"); + + _glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC)uiGLGetProcAddress("glGenFramebuffers"); + _glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC)uiGLGetProcAddress("glDeleteFramebuffers"); + _glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC)uiGLGetProcAddress("glBindFramebuffer"); + _glFramebufferTexture = (PFNGLFRAMEBUFFERTEXTUREPROC)uiGLGetProcAddress("glFramebufferTexture"); + _glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC)uiGLGetProcAddress("glFramebufferRenderbuffer"); + _glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC)uiGLGetProcAddress("glCheckFramebufferStatus"); + + _procsLoaded = 1; +} + +Display* derp; + uiGLContext *createGLContext(GtkGLArea* gla, int maj, int min) { - uiGLContext *ret = uiAlloc(sizeof(uiGLContext), "uiGLContext"); + printf("barp\n"); + uiGLContext *ret = uiNew(uiGLContext);//uiAlloc(sizeof(uiGLContext), "uiGLContext"); + + // herp + ret->gla = gla; + ret->gctx = NULL; + //while (!ret->gctx) + /*{ + gtk_widget_realize(GTK_WIDGET(gla)); + printf("is area realized: %d\n", gtk_widget_get_realized(GTK_WIDGET(gla))); ret->gla = gla; ret->gctx = gtk_gl_area_get_context(gla); + printf("context: %p\n", ret->gctx); + }*/ + + + + /* + GtkAllocation allocation; + GdkWindow *window; + Display *display; + int id; + + window = gtk_widget_get_window(widget); + display = gdk_x11_display_get_xdisplay(gdk_window_get_display(window)); + id = gdk_x11_window_get_xid(window); + + if (glXMakeCurrent(display, id, context) == TRUE) {*/ + + + /*GdkWindow* window; + Display* disp; + + window = gtk_widget_get_window(GTK_WIDGET(gla)); + display = */ + + + ret->vermaj = maj; ret->vermin = min; return ret; } +static void areaAllocRenderbuffer(uiGLContext* glctx); + +void databotte(GtkWidget* widget, uiGLContext* ctx) +{ + /*printf("is area realized: %d\n", gtk_widget_get_realized(GTK_WIDGET(gla))); + ctx->gctx = gtk_gl_area_get_context(gla); + printf("context: %p\n", ctx->gctx);*/ + + printf("DATABOTTE\n"); + + GdkWindow* gdkwin = gtk_widget_get_window(widget); + printf("window=%p\n", gdkwin); + + GError* err = NULL; + GdkGLContext* glctx = gdk_window_create_gl_context(gdkwin, &err); + if (err != NULL) + { + printf("CONTEXT SHAT ITSELF\n"); + return; + } + + gdk_gl_context_set_use_es(glctx, FALSE); + gdk_gl_context_set_required_version(glctx, 3, 2); + + gdk_gl_context_realize(glctx, &err); + if (err != NULL) + { + printf("CONTEXT REALIZE SHAT ITSELF\n"); + return; + } + + GtkAllocation allocation; + gtk_widget_get_allocation(widget, &allocation); + int window_scale = gdk_window_get_scale_factor(gdkwin); + ctx->width = allocation.width; + ctx->height = allocation.height; + ctx->scale = window_scale; + + gdk_gl_context_make_current(glctx); + _loadGLProcs(); + areaAllocRenderbuffer(ctx); + + ctx->widget = widget; + ctx->window = gdkwin; + ctx->gctx = glctx; +} + +static void areaAllocRenderbuffer(uiGLContext* glctx) +{ + _glGenRenderbuffers(2, &glctx->renderbuffer[0]);printf("ylarg0 %04X, %d %d\n", glGetError(), glctx->width, glctx->height); + //glGenTextures(2, &glctx->renderbuffer[0]); + _glGenFramebuffers(1, &glctx->framebuffer);printf("ylarg1 %04X\n", glGetError()); + printf("FB %08X created under ctx %p (%p %p)\n", glctx?glctx->framebuffer:0, gdk_gl_context_get_current(), glctx?glctx->gctx:NULL, glctx); + /*glBindTexture(GL_TEXTURE_2D, glctx->renderbuffer[0]); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + + glBindTexture(GL_TEXTURE_2D, glctx->renderbuffer[1]); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);*/ + + _glBindRenderbuffer(GL_RENDERBUFFER, glctx->renderbuffer[0]);printf("ylarg1 %04X\n", glGetError()); + _glRenderbufferStorage(GL_RENDERBUFFER, GL_RGB, glctx->width*glctx->scale, glctx->height*glctx->scale);printf("ylarg1 %04X\n", glGetError()); + _glBindRenderbuffer(GL_RENDERBUFFER, glctx->renderbuffer[1]);printf("ylarg1 %04X\n", glGetError()); + _glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_STENCIL, glctx->width*glctx->scale, glctx->height*glctx->scale);printf("ylarg1 %04X\n", glGetError()); + + _glBindFramebuffer(GL_FRAMEBUFFER, glctx->framebuffer);printf("ylarg2 %04X\n", glGetError()); + /*_glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, glctx->renderbuffer[0], 0); + _glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, glctx->renderbuffer[1], 0);*/ + _glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, glctx->renderbuffer[0]);printf("ylarg3 %04X\n", glGetError()); + _glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, glctx->renderbuffer[1]);printf("ylarg4 %04X\n", glGetError()); + //printf("ylarg: %08X, %04X, %08X %08X\n", glctx->framebuffer, glGetError(), glctx->renderbuffer[0], glctx->renderbuffer[1]); + + if(_glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) + printf("FRAMEBUFFER IS BAD!! %04X\n", _glCheckFramebufferStatus(GL_FRAMEBUFFER)); + + int alpha_size; + _glBindRenderbuffer(GL_RENDERBUFFER, glctx->renderbuffer[0]); + _glGetRenderbufferParameteriv (GL_RENDERBUFFER, GL_RENDERBUFFER_ALPHA_SIZE, &alpha_size); + printf("FRAMEBUFFER GOOD. ALPHA SIZE IS %d\n", alpha_size); +} + +static void areaRellocRenderbuffer(uiGLContext* glctx) +{ + _glBindRenderbuffer(GL_RENDERBUFFER, glctx->renderbuffer[0]); + _glRenderbufferStorage(GL_RENDERBUFFER, GL_RGB, glctx->width*glctx->scale, glctx->height*glctx->scale); + _glBindRenderbuffer(GL_RENDERBUFFER, glctx->renderbuffer[1]); + _glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_STENCIL, glctx->width*glctx->scale, glctx->height*glctx->scale); +} + +void areaDrawGL(GtkWidget* widget, uiAreaDrawParams* dp, cairo_t* cr, uiGLContext* glctx) +{ + int window_scale = gdk_window_get_scale_factor(glctx->window); + + if (glctx->width != dp->AreaWidth || glctx->height != dp->AreaHeight || glctx->scale != window_scale) + { + glctx->width = dp->AreaWidth; + glctx->height = dp->AreaHeight; + glctx->scale = window_scale; + areaRellocRenderbuffer(glctx); + } + + gdk_cairo_draw_from_gl(cr, gtk_widget_get_window(widget), + glctx->renderbuffer[0], GL_RENDERBUFFER, + 1, 0, 0, glctx->width*glctx->scale, glctx->height*glctx->scale); +} + +uiGLContext* FARTOMATIC(int major, int minor) +{ + uiGLContext *_ret = uiNew(uiGLContext); + _ret->vermaj = major; + _ret->vermin = minor; + _ret->width = -1; + _ret->height = -1; + _ret->renderbuffer[0] = 0; + _ret->renderbuffer[1] = 0; + _ret->framebuffer = 0; + + return _ret; + + Display* disp; + XVisualInfo* vizir; + GLXFBConfig *cfg; + Pixmap pm; + GLXPixmap glxpm; + GLXContext ctx; + + disp = XOpenDisplay(NULL); + derp = disp; + + int kaa, baa; + glXQueryVersion(disp, &kaa, &baa); + printf("GL VERSION: %d.%d\n", kaa, baa); + + const int sbAttrib[] = { GLX_RGBA, + GLX_RED_SIZE, 1, + GLX_GREEN_SIZE, 1, + GLX_BLUE_SIZE, 1, + None }; + const int dbAttrib[] = { GLX_RGBA, + GLX_RED_SIZE, 1, + GLX_GREEN_SIZE, 1, + GLX_BLUE_SIZE, 1, + GLX_DOUBLEBUFFER, + None }; + + int scrnum = DefaultScreen( disp ); + Window root = RootWindow( disp, scrnum ); + + vizir = glXChooseVisual( disp, scrnum, (int *) sbAttrib ); + if (!vizir) { + vizir = glXChooseVisual( disp, scrnum, (int *) dbAttrib ); + if (!vizir) { + printf("Error: couldn't get an RGB visual\n"); + return NULL; + } + } + + const int fb_attr[] = { + GLX_RENDER_TYPE, GLX_RGBA_BIT, + GLX_DRAWABLE_TYPE, GLX_PBUFFER_BIT, + GLX_X_VISUAL_TYPE, GLX_TRUE_COLOR, + GLX_DOUBLEBUFFER, True, + GLX_X_RENDERABLE, True, + GLX_RED_SIZE, 8, + GLX_GREEN_SIZE, 8, + GLX_BLUE_SIZE, 8, + GLX_ALPHA_SIZE, 8, + GLX_DEPTH_SIZE, 24, + GLX_STENCIL_SIZE, 8, + None + }; + int configs; + cfg = glXChooseFBConfig(disp, scrnum, (int *)&fb_attr, &configs); + + if (!cfg) + { + printf("NO GOOD FBCONFIG\n"); + return NULL; + } + + /*ctx = glXCreateContext( disp, vizir, NULL, True ); + if (!ctx) + { + printf("Error: glXCreateContext failed\n"); + return NULL; + }*/ + + PFNGLXCREATECONTEXTATTRIBSARBPROC createctx; + createctx = (PFNGLXCREATECONTEXTATTRIBSARBPROC)glXGetProcAddressARB("glXCreateContextAttribsARB"); + if (!createctx) + { + printf("bad shito\n"); + return NULL; + } + + const int ctx_attr[] = + { + GLX_CONTEXT_PROFILE_MASK_ARB, GLX_CONTEXT_CORE_PROFILE_BIT_ARB, + GLX_CONTEXT_MAJOR_VERSION_ARB, 3,//major, + GLX_CONTEXT_MINOR_VERSION_ARB, 2,//minor, + None + }; + + ctx = glXCreateContextAttribsARB(disp, cfg[0], 0, True, ctx_attr); + if (!ctx) + { + printf("FAILED TO CREATE FANCYPANTS GL CONTEXT\n"); + return NULL; + } + + //printf("CONTEXT GOOD. Direct rendering: %s\n", glXIsDirect(disp, ctx) ? "Yes" : "No"); + + printf("blorp: %d\n", vizir->depth); + pm = XCreatePixmap(disp, root, 256, 384, vizir->depth); + if (!pm) printf("PIXMAP SHAT ITSELF\n"); + else printf("PIXMAP GOOD\n"); + + glxpm = glXCreateGLXPixmap(disp, vizir, pm); + if (!glxpm) printf("GLXPIXMAP SHAT ITSELF\n"); + else printf("GLXPIXMAP GOOD\n"); + + uiGLContext *ret = uiNew(uiGLContext); + printf("CREATE CTX: %p, %p\n", ret, g_thread_self()); + ret->xdisp = disp; + ret->glxpm = glxpm; + ret->glxctx = ctx; + + return ret; +} + +int uiGLGetFramebuffer(uiGLContext* ctx) +{ + return ctx->framebuffer; +} + +float uiGLGetFramebufferScale(uiGLContext* ctx) +{ + return (float)ctx->scale; +} + void uiGLSwapBuffers(uiGLContext* ctx) { if (!ctx) return; - gtk_gl_area_attach_buffers(ctx->gla); + //gtk_gl_area_attach_buffers(ctx->gla); +} + +static volatile int _ctxset_done; + +gboolean _threadsafe_ctxset(gpointer data) +{ + uiGLContext* ctx = (uiGLContext*)data; + gtk_gl_area_make_current(ctx->gla); + _ctxset_done = 1; + return FALSE; } void uiGLMakeContextCurrent(uiGLContext* ctx) { - if (!ctx) return; - gtk_gl_area_make_current(ctx->gla); + //if (!ctx) return; + /*if (g_thread_self() != gtkthread) + { + _ctxset_done = 0; + g_idle_add(_threadsafe_ctxset, ctx); + while (!_ctxset_done); + } + else*/ + //gtk_gl_area_make_current(ctx->gla); + /*printf("MAKE CONTEXT CURRENT %p, %p\n", ctx, g_thread_self()); + if (!ctx) + { + // BLERUGEHZFZF + glXMakeCurrent(derp, None, NULL); + return; + } + Bool ret = True; + if (glXGetCurrentContext() != ctx->glxctx) + {printf("DZJSKFLD\n"); + ret = glXMakeCurrent(ctx->xdisp, ctx->glxpm, ctx->glxctx); + //glXMakeContextCurrent(ctx->xdisp, ctx->glxpm, ctx->glxpm, ctx->glxctx); + } + printf("WE MAED IT CURRENT: %d\n", ret);*/ + + printf("[%p] MAKE CONTEXT CURRENT %p, %p\n", g_thread_self(), ctx, ctx?ctx->gctx:NULL); + if (!ctx) + { + gdk_gl_context_clear_current(); + return; + } + //gtk_gl_area_make_current(ctx->gla); + gdk_gl_context_make_current(ctx->gctx); + GdkGLContext* burp = gdk_gl_context_get_current(); + //gtk_gl_area_attach_buffers(ctx->gla); + //printf("burp = %p / %p\n", burp, ctx->gctx); } void *uiGLGetProcAddress(const char* proc) { +printf("get: %s - ", proc); +void* a = dlsym(NULL, proc); +void* b = glXGetProcAddress(proc); +void* c = glXGetProcAddressARB(proc); +printf("%p / %p / %p\n", a, b, c); +return c; // this *will* break for older systems that don't have libglvnd! // TODO: use a real solution return dlsym(NULL /* RTLD_DEFAULT */, proc); |