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 *) glXGetProcAddressARB(const unsigned char* procName);
static gl_loader gl;
static glx_loader glx;
extern overlay_params params;
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) {
if (!gl.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);
}
glx.Load();
void *func = nullptr;
if (gl.glXGetProcAddress)
func = gl.glXGetProcAddress( (const unsigned char*) name );
if (glx.GetProcAddress)
func = glx.GetProcAddress( (const unsigned char*) name );
if (!func && gl.glXGetProcAddressARB)
func = gl.glXGetProcAddressARB( (const unsigned char*) name );
if (!func && glx.GetProcAddressARB)
func = glx.GetProcAddressARB( (const unsigned char*) name );
if (!func)
func = get_proc_address( name );
@ -79,8 +73,8 @@ Status XGetGeometry(
EXPORT_C_(void *) glXCreateContext(void *dpy, void *vis, void *shareList, int direct)
{
gl.Load();
void *ctx = gl.glXCreateContext(dpy, vis, shareList, direct);
glx.Load();
void *ctx = glx.CreateContext(dpy, vis, shareList, direct);
#ifndef NDEBUG
std::cerr << __func__ << ":" << ctx << std::endl;
#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) {
gl.Load();
glx.Load();
#ifndef NDEBUG
std::cerr << __func__ << ": " << drawable << ", " << ctx << std::endl;
#endif
bool ret = gl.glXMakeCurrent(dpy, drawable, ctx);
bool ret = glx.MakeCurrent(dpy, drawable, ctx);
if (ret)
imgui_set_context(ctx);
if (params.gl_vsync >= -1) {
if (gl.glXSwapIntervalEXT)
gl.glXSwapIntervalEXT(dpy, drawable, params.gl_vsync);
if (gl.glXSwapIntervalSGI)
gl.glXSwapIntervalSGI(params.gl_vsync);
if (gl.glXSwapIntervalMESA)
gl.glXSwapIntervalMESA(params.gl_vsync);
if (glx.SwapIntervalEXT)
glx.SwapIntervalEXT(dpy, drawable, params.gl_vsync);
if (glx.SwapIntervalSGI)
glx.SwapIntervalSGI(params.gl_vsync);
if (glx.SwapIntervalMESA)
glx.SwapIntervalMESA(params.gl_vsync);
}
return ret;
}
EXPORT_C_(void) glXSwapBuffers(void* dpy, void* drawable) {
gl.Load();
imgui_create(gl.glXGetCurrentContext());
glx.Load();
imgui_create(glx.GetCurrentContext());
unsigned int width, height;
//gl.glXQueryDrawable(dpy, drawable, 0x801D /*GLX_WIDTH*/, &width);
//gl.glXQueryDrawable(dpy, drawable, 0x801E /*GLX_HEIGTH*/, &height);
//glx.QueryDrawable(dpy, drawable, 0x801D /*GLX_WIDTH*/, &width);
//glx.QueryDrawable(dpy, drawable, 0x801E /*GLX_HEIGTH*/, &height);
// glXQueryDrawable is buggy, use XGetGeometry instead
Window unused_window;
@ -130,7 +124,7 @@ EXPORT_C_(void) glXSwapBuffers(void* dpy, void* drawable) {
height = vp[3];*/
imgui_render(width, height);
gl.glXSwapBuffers(dpy, drawable);
glx.SwapBuffers(dpy, drawable);
if (fps_limit_stats.targetFrameTime > 0){
fps_limit_stats.frameStart = os_time_get_nano();
FpsLimiter(fps_limit_stats);
@ -143,42 +137,42 @@ EXPORT_C_(void) glXSwapIntervalEXT(void *dpy, void *draw, int interval) {
std::cerr << __func__ << ": " << interval << std::endl;
#endif
gl.Load();
glx.Load();
if (params.gl_vsync >= 0)
interval = params.gl_vsync;
gl.glXSwapIntervalEXT(dpy, draw, interval);
glx.SwapIntervalEXT(dpy, draw, interval);
}
EXPORT_C_(int) glXSwapIntervalSGI(int interval) {
#ifndef NDEBUG
std::cerr << __func__ << ": " << interval << std::endl;
#endif
gl.Load();
glx.Load();
if (params.gl_vsync >= 0)
interval = params.gl_vsync;
return gl.glXSwapIntervalSGI(interval);
return glx.SwapIntervalSGI(interval);
}
EXPORT_C_(int) glXSwapIntervalMESA(unsigned int interval) {
#ifndef NDEBUG
std::cerr << __func__ << ": " << interval << std::endl;
#endif
gl.Load();
glx.Load();
if (params.gl_vsync >= 0)
interval = (unsigned int)params.gl_vsync;
return gl.glXSwapIntervalMESA(interval);
return glx.SwapIntervalMESA(interval);
}
EXPORT_C_(int) glXGetSwapIntervalMESA() {
gl.Load();
glx.Load();
static bool first_call = true;
int interval = gl.glXGetSwapIntervalMESA();
int interval = glx.GetSwapIntervalMESA();
if (first_call) {
first_call = false;
if (params.gl_vsync >= 0) {
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 "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_);
}
bool gl_loader::Load(void *handle, bool egl_only) {
bool glx_loader::Load() {
if (loaded_) {
return true;
}
if (!handle)
handle = RTLD_NEXT;
eglSwapBuffers =
reinterpret_cast<decltype(this->eglSwapBuffers)>(
real_dlsym(handle, "eglSwapBuffers"));
if (egl_only) {
loaded_ = true;
return true;
// Force load libGL
void *handle = real_dlopen("libGL.so.1", RTLD_LAZY);
if (!handle) {
std::cerr << "MANGOHUD: couldn't find libGL.so.1" << std::endl;
return false;
}
glXGetProcAddress =
reinterpret_cast<decltype(this->glXGetProcAddress)>(
GetProcAddress =
reinterpret_cast<decltype(this->GetProcAddress)>(
real_dlsym(handle, "glXGetProcAddress"));
glXGetProcAddressARB =
reinterpret_cast<decltype(this->glXGetProcAddressARB)>(
GetProcAddressARB =
reinterpret_cast<decltype(this->GetProcAddressARB)>(
real_dlsym(handle, "glXGetProcAddressARB"));
if (!glXGetProcAddress) {
if (!GetProcAddress) {
CleanUp(true);
return false;
}
glXCreateContext =
reinterpret_cast<decltype(this->glXCreateContext)>(
glXGetProcAddress((const unsigned char *)"glXCreateContext"));
if (!glXCreateContext) {
CreateContext =
reinterpret_cast<decltype(this->CreateContext)>(
GetProcAddress((const unsigned char *)"glXCreateContext"));
if (!CreateContext) {
CleanUp(true);
return false;
}
glXDestroyContext =
reinterpret_cast<decltype(this->glXDestroyContext)>(
glXGetProcAddress((const unsigned char *)"glXDestroyContext"));
if (!glXDestroyContext) {
DestroyContext =
reinterpret_cast<decltype(this->DestroyContext)>(
GetProcAddress((const unsigned char *)"glXDestroyContext"));
if (!DestroyContext) {
CleanUp(true);
return false;
}
glXGetCurrentContext =
reinterpret_cast<decltype(this->glXGetCurrentContext)>(
glXGetProcAddress((const unsigned char *)"glXGetCurrentContext"));
if (!glXGetCurrentContext) {
GetCurrentContext =
reinterpret_cast<decltype(this->GetCurrentContext)>(
GetProcAddress((const unsigned char *)"glXGetCurrentContext"));
if (!GetCurrentContext) {
CleanUp(true);
return false;
}
glXSwapBuffers =
reinterpret_cast<decltype(this->glXSwapBuffers)>(
glXGetProcAddress((const unsigned char *)"glXSwapBuffers"));
if (!glXSwapBuffers) {
SwapBuffers =
reinterpret_cast<decltype(this->SwapBuffers)>(
GetProcAddress((const unsigned char *)"glXSwapBuffers"));
if (!SwapBuffers) {
CleanUp(true);
return false;
}
glXSwapIntervalEXT =
reinterpret_cast<decltype(this->glXSwapIntervalEXT)>(
glXGetProcAddress((const unsigned char *)"glXSwapIntervalEXT"));
SwapIntervalEXT =
reinterpret_cast<decltype(this->SwapIntervalEXT)>(
GetProcAddress((const unsigned char *)"glXSwapIntervalEXT"));
glXSwapIntervalSGI =
reinterpret_cast<decltype(this->glXSwapIntervalSGI)>(
glXGetProcAddress((const unsigned char *)"glXSwapIntervalSGI"));
SwapIntervalSGI =
reinterpret_cast<decltype(this->SwapIntervalSGI)>(
GetProcAddress((const unsigned char *)"glXSwapIntervalSGI"));
glXSwapIntervalMESA =
reinterpret_cast<decltype(this->glXSwapIntervalMESA)>(
glXGetProcAddress((const unsigned char *)"glXSwapIntervalMESA"));
SwapIntervalMESA =
reinterpret_cast<decltype(this->SwapIntervalMESA)>(
GetProcAddress((const unsigned char *)"glXSwapIntervalMESA"));
glXGetSwapIntervalMESA =
reinterpret_cast<decltype(this->glXGetSwapIntervalMESA)>(
glXGetProcAddress((const unsigned char *)"glXGetSwapIntervalMESA"));
GetSwapIntervalMESA =
reinterpret_cast<decltype(this->GetSwapIntervalMESA)>(
GetProcAddress((const unsigned char *)"glXGetSwapIntervalMESA"));
glXQueryDrawable =
reinterpret_cast<decltype(this->glXQueryDrawable)>(
glXGetProcAddress((const unsigned char *)"glXQueryDrawable"));
QueryDrawable =
reinterpret_cast<decltype(this->QueryDrawable)>(
GetProcAddress((const unsigned char *)"glXQueryDrawable"));
glXMakeCurrent =
reinterpret_cast<decltype(this->glXMakeCurrent)>(
glXGetProcAddress((const unsigned char *)"glXMakeCurrent"));
if (!glXMakeCurrent) {
MakeCurrent =
reinterpret_cast<decltype(this->MakeCurrent)>(
GetProcAddress((const unsigned char *)"glXMakeCurrent"));
if (!MakeCurrent) {
CleanUp(true);
return false;
}
@ -102,17 +98,19 @@ bool gl_loader::Load(void *handle, bool egl_only) {
return true;
}
void gl_loader::CleanUp(bool unload) {
void glx_loader::CleanUp(bool unload) {
loaded_ = false;
glXGetProcAddress = nullptr;
glXGetProcAddressARB = nullptr;
glXCreateContext = nullptr;
glXDestroyContext = nullptr;
glXSwapBuffers = nullptr;
glXSwapIntervalEXT = nullptr;
glXSwapIntervalSGI = nullptr;
glXSwapIntervalMESA = nullptr;
glXQueryDrawable = nullptr;
glXMakeCurrent = nullptr;
GetProcAddress = nullptr;
GetProcAddressARB = nullptr;
CreateContext = nullptr;
DestroyContext = nullptr;
SwapBuffers = nullptr;
SwapIntervalEXT = nullptr;
SwapIntervalSGI = nullptr;
SwapIntervalMESA = nullptr;
QueryDrawable = 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
#define LIBRARY_LOADER_GL_H
#pragma once
#include "gl/gl.h"
#include <dlfcn.h>
class gl_loader {
class glx_loader {
public:
gl_loader();
~gl_loader();
glx_loader();
~glx_loader();
bool Load(void *handle = nullptr, bool egl_only = false);
bool Load();
bool IsLoaded() { return loaded_; }
decltype(&::glXGetProcAddress) glXGetProcAddress;
decltype(&::glXGetProcAddressARB) glXGetProcAddressARB;
decltype(&::glXCreateContext) glXCreateContext;
decltype(&::glXDestroyContext) glXDestroyContext;
decltype(&::glXSwapBuffers) glXSwapBuffers;
decltype(&::glXSwapIntervalEXT) glXSwapIntervalEXT;
decltype(&::glXSwapIntervalSGI) glXSwapIntervalSGI;
decltype(&::glXSwapIntervalMESA) glXSwapIntervalMESA;
decltype(&::glXGetSwapIntervalMESA) glXGetSwapIntervalMESA;
decltype(&::glXMakeCurrent) glXMakeCurrent;
decltype(&::glXGetCurrentContext) glXGetCurrentContext;
decltype(&::glXQueryDrawable) glXQueryDrawable;
decltype(&::eglSwapBuffers) eglSwapBuffers;
decltype(&::glXGetProcAddress) GetProcAddress;
decltype(&::glXGetProcAddressARB) GetProcAddressARB;
decltype(&::glXCreateContext) CreateContext;
decltype(&::glXDestroyContext) DestroyContext;
decltype(&::glXSwapBuffers) SwapBuffers;
decltype(&::glXSwapIntervalEXT) SwapIntervalEXT;
decltype(&::glXSwapIntervalSGI) SwapIntervalSGI;
decltype(&::glXSwapIntervalMESA) SwapIntervalMESA;
decltype(&::glXGetSwapIntervalMESA) GetSwapIntervalMESA;
decltype(&::glXMakeCurrent) MakeCurrent;
decltype(&::glXGetCurrentContext) GetCurrentContext;
decltype(&::glXQueryDrawable) QueryDrawable;
private:
void CleanUp(bool unload);
@ -33,8 +29,6 @@ class gl_loader {
bool loaded_;
// Disallow copy constructor and assignment operator.
gl_loader(const gl_loader&);
void operator=(const gl_loader&);
glx_loader(const glx_loader&);
void operator=(const glx_loader&);
};
#endif // LIBRARY_LOADER_GL_H

Write Preview
Loading…
Cancel
Save