Archives
/
MangoHud
mirror of https://github.com/flightlessmango/MangoHud
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

[OpenGL] Rename GLX loader functions

Browse Source
pull/131/head
jackun 4 years ago
parent b2e6727b25
commit 0a36578adf
No known key found for this signature in database
GPG Key ID: 119DB3F1D05A9ED3
3 changed files with 111 additions and 125 deletions
Show Stats Download Patch File Download Diff File

66
src/gl/inject_glx.cpp
Unescape Escape View File

@ -17,7 +17,7 @@
EXPORT_C_(void *) glXGetProcAddress(const unsigned char* procName); EXPORT_C_(void *) glXGetProcAddress(const unsigned char* procName);
EXPORT_C_(void *) glXGetProcAddressARB(const unsigned char* procName); EXPORT_C_(void *) glXGetProcAddressARB(const unsigned char* procName);
static gl_loader gl; static glx_loader glx;
extern overlay_params params; extern overlay_params params;
void* get_proc_address(const char* name) { void* get_proc_address(const char* name) {
@ -32,20 +32,14 @@ void* get_proc_address(const char* name) {
} }
void* get_glx_proc_address(const char* name) { void* get_glx_proc_address(const char* name) {
if (!gl.Load()) { glx.Load();
// Force load libGL then. If it still doesn't find it, get_proc_address should quit the program
void *handle = real_dlopen("libGL.so.1", RTLD_LAZY);
if (!handle)
std::cerr << "MANGOHUD: couldn't find libGL.so.1" << std::endl;
gl.Load(handle);
}
void *func = nullptr; void *func = nullptr;
if (gl.glXGetProcAddress) if (glx.GetProcAddress)
func = gl.glXGetProcAddress( (const unsigned char*) name ); func = glx.GetProcAddress( (const unsigned char*) name );
if (!func && gl.glXGetProcAddressARB) if (!func && glx.GetProcAddressARB)
func = gl.glXGetProcAddressARB( (const unsigned char*) name ); func = glx.GetProcAddressARB( (const unsigned char*) name );
if (!func) if (!func)
func = get_proc_address( name ); func = get_proc_address( name );
@ -79,8 +73,8 @@ Status XGetGeometry(
EXPORT_C_(void *) glXCreateContext(void *dpy, void *vis, void *shareList, int direct) EXPORT_C_(void *) glXCreateContext(void *dpy, void *vis, void *shareList, int direct)
{ {
gl.Load(); glx.Load();
void *ctx = gl.glXCreateContext(dpy, vis, shareList, direct); void *ctx = glx.CreateContext(dpy, vis, shareList, direct);
#ifndef NDEBUG #ifndef NDEBUG
std::cerr << __func__ << ":" << ctx << std::endl; std::cerr << __func__ << ":" << ctx << std::endl;
#endif #endif
@ -88,34 +82,34 @@ EXPORT_C_(void *) glXCreateContext(void *dpy, void *vis, void *shareList, int di
} }
EXPORT_C_(bool) glXMakeCurrent(void* dpy, void* drawable, void* ctx) { EXPORT_C_(bool) glXMakeCurrent(void* dpy, void* drawable, void* ctx) {
gl.Load(); glx.Load();
#ifndef NDEBUG #ifndef NDEBUG
std::cerr << __func__ << ": " << drawable << ", " << ctx << std::endl; std::cerr << __func__ << ": " << drawable << ", " << ctx << std::endl;
#endif #endif
bool ret = gl.glXMakeCurrent(dpy, drawable, ctx); bool ret = glx.MakeCurrent(dpy, drawable, ctx);
if (ret) if (ret)
imgui_set_context(ctx); imgui_set_context(ctx);
if (params.gl_vsync >= -1) { if (params.gl_vsync >= -1) {
if (gl.glXSwapIntervalEXT) if (glx.SwapIntervalEXT)
gl.glXSwapIntervalEXT(dpy, drawable, params.gl_vsync); glx.SwapIntervalEXT(dpy, drawable, params.gl_vsync);
if (gl.glXSwapIntervalSGI) if (glx.SwapIntervalSGI)
gl.glXSwapIntervalSGI(params.gl_vsync); glx.SwapIntervalSGI(params.gl_vsync);
if (gl.glXSwapIntervalMESA) if (glx.SwapIntervalMESA)
gl.glXSwapIntervalMESA(params.gl_vsync); glx.SwapIntervalMESA(params.gl_vsync);
} }
return ret; return ret;
} }
EXPORT_C_(void) glXSwapBuffers(void* dpy, void* drawable) { EXPORT_C_(void) glXSwapBuffers(void* dpy, void* drawable) {
gl.Load(); glx.Load();
imgui_create(gl.glXGetCurrentContext()); imgui_create(glx.GetCurrentContext());
unsigned int width, height; unsigned int width, height;
//gl.glXQueryDrawable(dpy, drawable, 0x801D /*GLX_WIDTH*/, &width); //glx.QueryDrawable(dpy, drawable, 0x801D /*GLX_WIDTH*/, &width);
//gl.glXQueryDrawable(dpy, drawable, 0x801E /*GLX_HEIGTH*/, &height); //glx.QueryDrawable(dpy, drawable, 0x801E /*GLX_HEIGTH*/, &height);
// glXQueryDrawable is buggy, use XGetGeometry instead // glXQueryDrawable is buggy, use XGetGeometry instead
Window unused_window; Window unused_window;
@ -130,7 +124,7 @@ EXPORT_C_(void) glXSwapBuffers(void* dpy, void* drawable) {
height = vp[3];*/ height = vp[3];*/
imgui_render(width, height); imgui_render(width, height);
gl.glXSwapBuffers(dpy, drawable); glx.SwapBuffers(dpy, drawable);
if (fps_limit_stats.targetFrameTime > 0){ if (fps_limit_stats.targetFrameTime > 0){
fps_limit_stats.frameStart = os_time_get_nano(); fps_limit_stats.frameStart = os_time_get_nano();
FpsLimiter(fps_limit_stats); FpsLimiter(fps_limit_stats);
@ -143,42 +137,42 @@ EXPORT_C_(void) glXSwapIntervalEXT(void *dpy, void *draw, int interval) {
std::cerr << __func__ << ": " << interval << std::endl; std::cerr << __func__ << ": " << interval << std::endl;
#endif #endif
gl.Load(); glx.Load();
if (params.gl_vsync >= 0) if (params.gl_vsync >= 0)
interval = params.gl_vsync; interval = params.gl_vsync;
gl.glXSwapIntervalEXT(dpy, draw, interval); glx.SwapIntervalEXT(dpy, draw, interval);
} }
EXPORT_C_(int) glXSwapIntervalSGI(int interval) { EXPORT_C_(int) glXSwapIntervalSGI(int interval) {
#ifndef NDEBUG #ifndef NDEBUG
std::cerr << __func__ << ": " << interval << std::endl; std::cerr << __func__ << ": " << interval << std::endl;
#endif #endif
gl.Load(); glx.Load();
if (params.gl_vsync >= 0) if (params.gl_vsync >= 0)
interval = params.gl_vsync; interval = params.gl_vsync;
return gl.glXSwapIntervalSGI(interval); return glx.SwapIntervalSGI(interval);
} }
EXPORT_C_(int) glXSwapIntervalMESA(unsigned int interval) { EXPORT_C_(int) glXSwapIntervalMESA(unsigned int interval) {
#ifndef NDEBUG #ifndef NDEBUG
std::cerr << __func__ << ": " << interval << std::endl; std::cerr << __func__ << ": " << interval << std::endl;
#endif #endif
gl.Load(); glx.Load();
if (params.gl_vsync >= 0) if (params.gl_vsync >= 0)
interval = (unsigned int)params.gl_vsync; interval = (unsigned int)params.gl_vsync;
return gl.glXSwapIntervalMESA(interval); return glx.SwapIntervalMESA(interval);
} }
EXPORT_C_(int) glXGetSwapIntervalMESA() { EXPORT_C_(int) glXGetSwapIntervalMESA() {
gl.Load(); glx.Load();
static bool first_call = true; static bool first_call = true;
int interval = gl.glXGetSwapIntervalMESA(); int interval = glx.GetSwapIntervalMESA();
if (first_call) { if (first_call) {
first_call = false; first_call = false;
if (params.gl_vsync >= 0) { if (params.gl_vsync >= 0) {
interval = params.gl_vsync; interval = params.gl_vsync;
gl.glXSwapIntervalMESA(interval); glx.SwapIntervalMESA(interval);
} }
} }

126
src/loaders/loader_glx.cpp
Unescape Escape View File

@ -1,99 +1,95 @@
#include <iostream>
#include "real_dlsym.h" #include "real_dlsym.h"
#include "loaders/loader_glx.h" #include "loaders/loader_glx.h"
gl_loader::gl_loader() : loaded_(false) { glx_loader::glx_loader() : loaded_(false) {
} }
gl_loader::~gl_loader() { glx_loader::~glx_loader() {
CleanUp(loaded_); CleanUp(loaded_);
} }
bool gl_loader::Load(void *handle, bool egl_only) { bool glx_loader::Load() {
if (loaded_) { if (loaded_) {
return true; return true;
} }
if (!handle) // Force load libGL
handle = RTLD_NEXT; void *handle = real_dlopen("libGL.so.1", RTLD_LAZY);
if (!handle) {
eglSwapBuffers = std::cerr << "MANGOHUD: couldn't find libGL.so.1" << std::endl;
reinterpret_cast<decltype(this->eglSwapBuffers)>( return false;
real_dlsym(handle, "eglSwapBuffers"));
if (egl_only) {
loaded_ = true;
return true;
} }
glXGetProcAddress = GetProcAddress =
reinterpret_cast<decltype(this->glXGetProcAddress)>( reinterpret_cast<decltype(this->GetProcAddress)>(
real_dlsym(handle, "glXGetProcAddress")); real_dlsym(handle, "glXGetProcAddress"));
glXGetProcAddressARB = GetProcAddressARB =
reinterpret_cast<decltype(this->glXGetProcAddressARB)>( reinterpret_cast<decltype(this->GetProcAddressARB)>(
real_dlsym(handle, "glXGetProcAddressARB")); real_dlsym(handle, "glXGetProcAddressARB"));
if (!glXGetProcAddress) { if (!GetProcAddress) {
CleanUp(true); CleanUp(true);
return false; return false;
} }
glXCreateContext = CreateContext =
reinterpret_cast<decltype(this->glXCreateContext)>( reinterpret_cast<decltype(this->CreateContext)>(
glXGetProcAddress((const unsigned char *)"glXCreateContext")); GetProcAddress((const unsigned char *)"glXCreateContext"));
if (!glXCreateContext) { if (!CreateContext) {
CleanUp(true); CleanUp(true);
return false; return false;
} }
glXDestroyContext = DestroyContext =
reinterpret_cast<decltype(this->glXDestroyContext)>( reinterpret_cast<decltype(this->DestroyContext)>(
glXGetProcAddress((const unsigned char *)"glXDestroyContext")); GetProcAddress((const unsigned char *)"glXDestroyContext"));
if (!glXDestroyContext) { if (!DestroyContext) {
CleanUp(true); CleanUp(true);
return false; return false;
} }
glXGetCurrentContext = GetCurrentContext =
reinterpret_cast<decltype(this->glXGetCurrentContext)>( reinterpret_cast<decltype(this->GetCurrentContext)>(
glXGetProcAddress((const unsigned char *)"glXGetCurrentContext")); GetProcAddress((const unsigned char *)"glXGetCurrentContext"));
if (!glXGetCurrentContext) { if (!GetCurrentContext) {
CleanUp(true); CleanUp(true);
return false; return false;
} }
glXSwapBuffers = SwapBuffers =
reinterpret_cast<decltype(this->glXSwapBuffers)>( reinterpret_cast<decltype(this->SwapBuffers)>(
glXGetProcAddress((const unsigned char *)"glXSwapBuffers")); GetProcAddress((const unsigned char *)"glXSwapBuffers"));
if (!glXSwapBuffers) { if (!SwapBuffers) {
CleanUp(true); CleanUp(true);
return false; return false;
} }
glXSwapIntervalEXT = SwapIntervalEXT =
reinterpret_cast<decltype(this->glXSwapIntervalEXT)>( reinterpret_cast<decltype(this->SwapIntervalEXT)>(
glXGetProcAddress((const unsigned char *)"glXSwapIntervalEXT")); GetProcAddress((const unsigned char *)"glXSwapIntervalEXT"));
glXSwapIntervalSGI = SwapIntervalSGI =
reinterpret_cast<decltype(this->glXSwapIntervalSGI)>( reinterpret_cast<decltype(this->SwapIntervalSGI)>(
glXGetProcAddress((const unsigned char *)"glXSwapIntervalSGI")); GetProcAddress((const unsigned char *)"glXSwapIntervalSGI"));
glXSwapIntervalMESA = SwapIntervalMESA =
reinterpret_cast<decltype(this->glXSwapIntervalMESA)>( reinterpret_cast<decltype(this->SwapIntervalMESA)>(
glXGetProcAddress((const unsigned char *)"glXSwapIntervalMESA")); GetProcAddress((const unsigned char *)"glXSwapIntervalMESA"));
glXGetSwapIntervalMESA = GetSwapIntervalMESA =
reinterpret_cast<decltype(this->glXGetSwapIntervalMESA)>( reinterpret_cast<decltype(this->GetSwapIntervalMESA)>(
glXGetProcAddress((const unsigned char *)"glXGetSwapIntervalMESA")); GetProcAddress((const unsigned char *)"glXGetSwapIntervalMESA"));
glXQueryDrawable = QueryDrawable =
reinterpret_cast<decltype(this->glXQueryDrawable)>( reinterpret_cast<decltype(this->QueryDrawable)>(
glXGetProcAddress((const unsigned char *)"glXQueryDrawable")); GetProcAddress((const unsigned char *)"glXQueryDrawable"));
glXMakeCurrent = MakeCurrent =
reinterpret_cast<decltype(this->glXMakeCurrent)>( reinterpret_cast<decltype(this->MakeCurrent)>(
glXGetProcAddress((const unsigned char *)"glXMakeCurrent")); GetProcAddress((const unsigned char *)"glXMakeCurrent"));
if (!glXMakeCurrent) { if (!MakeCurrent) {
CleanUp(true); CleanUp(true);
return false; return false;
} }
@ -102,17 +98,19 @@ bool gl_loader::Load(void *handle, bool egl_only) {
return true; return true;
} }
void gl_loader::CleanUp(bool unload) { void glx_loader::CleanUp(bool unload) {
loaded_ = false; loaded_ = false;
glXGetProcAddress = nullptr; GetProcAddress = nullptr;
glXGetProcAddressARB = nullptr; GetProcAddressARB = nullptr;
glXCreateContext = nullptr; CreateContext = nullptr;
glXDestroyContext = nullptr; DestroyContext = nullptr;
glXSwapBuffers = nullptr; SwapBuffers = nullptr;
glXSwapIntervalEXT = nullptr; SwapIntervalEXT = nullptr;
glXSwapIntervalSGI = nullptr; SwapIntervalSGI = nullptr;
glXSwapIntervalMESA = nullptr; SwapIntervalMESA = nullptr;
glXQueryDrawable = nullptr; QueryDrawable = nullptr;
glXMakeCurrent = nullptr; MakeCurrent = nullptr;
} }
glx_loader glx;

44
src/loaders/loader_glx.h
Unescape Escape View File

@ -1,31 +1,27 @@
#ifndef LIBRARY_LOADER_GL_H #pragma once
#define LIBRARY_LOADER_GL_H
#include "gl/gl.h" #include "gl/gl.h"
#include <dlfcn.h> #include <dlfcn.h>
class gl_loader { class glx_loader {
public: public:
gl_loader(); glx_loader();
~gl_loader(); ~glx_loader();
bool Load(void *handle = nullptr, bool egl_only = false); bool Load();
bool IsLoaded() { return loaded_; } bool IsLoaded() { return loaded_; }
decltype(&::glXGetProcAddress) glXGetProcAddress; decltype(&::glXGetProcAddress) GetProcAddress;
decltype(&::glXGetProcAddressARB) glXGetProcAddressARB; decltype(&::glXGetProcAddressARB) GetProcAddressARB;
decltype(&::glXCreateContext) glXCreateContext; decltype(&::glXCreateContext) CreateContext;
decltype(&::glXDestroyContext) glXDestroyContext; decltype(&::glXDestroyContext) DestroyContext;
decltype(&::glXSwapBuffers) glXSwapBuffers; decltype(&::glXSwapBuffers) SwapBuffers;
decltype(&::glXSwapIntervalEXT) glXSwapIntervalEXT; decltype(&::glXSwapIntervalEXT) SwapIntervalEXT;
decltype(&::glXSwapIntervalSGI) glXSwapIntervalSGI; decltype(&::glXSwapIntervalSGI) SwapIntervalSGI;
decltype(&::glXSwapIntervalMESA) glXSwapIntervalMESA; decltype(&::glXSwapIntervalMESA) SwapIntervalMESA;
decltype(&::glXGetSwapIntervalMESA) glXGetSwapIntervalMESA; decltype(&::glXGetSwapIntervalMESA) GetSwapIntervalMESA;
decltype(&::glXMakeCurrent) glXMakeCurrent; decltype(&::glXMakeCurrent) MakeCurrent;
decltype(&::glXGetCurrentContext) glXGetCurrentContext; decltype(&::glXGetCurrentContext) GetCurrentContext;
decltype(&::glXQueryDrawable) glXQueryDrawable; decltype(&::glXQueryDrawable) QueryDrawable;
decltype(&::eglSwapBuffers) eglSwapBuffers;
private: private:
void CleanUp(bool unload); void CleanUp(bool unload);
@ -33,8 +29,6 @@ class gl_loader {
bool loaded_; bool loaded_;
// Disallow copy constructor and assignment operator. // Disallow copy constructor and assignment operator.
gl_loader(const gl_loader&); glx_loader(const glx_loader&);
void operator=(const gl_loader&); void operator=(const glx_loader&);
}; };
#endif // LIBRARY_LOADER_GL_H

Write Preview
Loading…
Cancel
Save