diff --git a/CMakeLists.txt b/CMakeLists.txt index e31ae3c79..cd339c78f 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -858,6 +858,7 @@ if(BOX32) "${BOX64_ROOT}/src/wrapped32/wrappedcrashhandler.c" "${BOX64_ROOT}/src/wrapped32/wrappedlibgl.c" "${BOX64_ROOT}/src/wrapped32/wrappedlibglu.c" + "${BOX64_ROOT}/src/wrapped32/wrappedlibglxnvidia.c" "${BOX64_ROOT}/src/wrapped32/wrappedsdl1.c" "${BOX64_ROOT}/src/wrapped32/wrappedsdl2.c" "${BOX64_ROOT}/src/wrapped32/wrappedsdl2image.c" diff --git a/rebuild_wrappers_32.py b/rebuild_wrappers_32.py index 437ab3364..6b4610584 100755 --- a/rebuild_wrappers_32.py +++ b/rebuild_wrappers_32.py @@ -876,6 +876,7 @@ def readFiles(files: Iterable[str]) -> Tuple[JumbledFunctions, JumbledFunctions, or match("appindicator","appindicator3")\ or match("libgl", "libegl") \ or match("libgl", "libglx") \ + or match("libgl", "libglxnvidia")\ \ or match("libc", "tcmallocminimal") \ or match("libc", "ldlinux") \ diff --git a/src/include/gltools.h b/src/include/gltools.h index bd7844c01..36b466077 100644 --- a/src/include/gltools.h +++ b/src/include/gltools.h @@ -10,7 +10,7 @@ void freeGLProcWrapper(box64context_t* context); void* getGLProcAddress(x64emu_t* emu, const char* my, glprocaddress_t procaddr, const char* rname); #ifdef BOX32 -void* getGLProcAddress32(x64emu_t* emu, glprocaddress_t procaddr, const char* rname); +void* getGLProcAddress32(x64emu_t* emu, const char* my, glprocaddress_t procaddr, const char* rname); #endif #endif //__GL_TOOLS_H__ \ No newline at end of file diff --git a/src/library_list_32.h b/src/library_list_32.h index 0c37f4a15..48c05bb41 100644 --- a/src/library_list_32.h +++ b/src/library_list_32.h @@ -27,7 +27,7 @@ GO("ld-linux.so.2", ldlinux) GO("libGL.so", libgl) GO("libGL.so.1", libgl) -GO("libGLX_nvidia.so.0", libgl) +GO("libGLX_nvidia.so.0", libglxnvidia) GO("libGLU.so.1", libglu) GO("libSDL-1.2.so.0", sdl1) GO("libSDL2-2.0.so.0", sdl2) diff --git a/src/wrapped32/generated/functions_list.txt b/src/wrapped32/generated/functions_list.txt index 09b98b31b..a1b0a2897 100644 --- a/src/wrapped32/generated/functions_list.txt +++ b/src/wrapped32/generated/functions_list.txt @@ -2792,6 +2792,63 @@ wrappedlibglx: - glXChooseFBConfig - pFXppi: - glXCreateContext +wrappedlibglxnvidia: +- iFi: + - glXSwapIntervalMESA +- pFp: + - glGetVkProcAddrNV + - glXGetProcAddress + - glXGetProcAddressARB +- vFip: + - glVDPAUMapSurfacesNV + - glVDPAUUnmapSurfacesNV +- vFpp: + - glDebugMessageCallback + - glDebugMessageCallbackAMD + - glDebugMessageCallbackARB + - glDebugMessageCallbackKHR +- iFpp: + - eglDebugMessageControlKHR +- pFXp: + - glXGetFBConfigFromVisualSGIX + - glXGetVisualFromFBConfig + - glXGetVisualFromFBConfigSGIX +- vFipp: + - glProgramCallbackMESA +- vFppp: + - eglSetBlobCacheFuncsANDROID +- vFXpi: + - glXSwapIntervalEXT +- uFuip: + - glCreateShaderProgramv +- pFXip: + - glXChooseVisual + - glXGetFBConfigs +- vFuipu: + - glTransformFeedbackVaryings + - glTransformFeedbackVaryingsEXT +- vFuipp: + - glCompileShaderIncludeARB + - glGetUniformIndices + - glShaderSource + - glShaderSourceARB +- pFXipp: + - glXChooseFBConfig + - glXChooseFBConfigSGIX +- pFXppi: + - glXCreateContext +- vFuippp: + - glBindVertexBuffers +- vFupupi: + - glMultiDrawElements + - glMultiDrawElementsEXT +- vFuuippp: + - glBindBuffersRange + - glVertexArrayVertexBuffers +- vFupupip: + - glMultiDrawElementsBaseVertex +- vFppupui: + - glMultiModeDrawElementsIBM wrappedlibm: - UEs: - cacosf diff --git a/src/wrapped32/generated/wrappedlibglxnvidiadefs32.h b/src/wrapped32/generated/wrappedlibglxnvidiadefs32.h new file mode 100644 index 000000000..6d8adcca3 --- /dev/null +++ b/src/wrapped32/generated/wrappedlibglxnvidiadefs32.h @@ -0,0 +1,8 @@ +/********************************************************************* + * File automatically generated by rebuild_wrappers_32.py (v0.0.2.2) * + *********************************************************************/ +#ifndef __wrappedlibglxnvidiaDEFS32_H_ +#define __wrappedlibglxnvidiaDEFS32_H_ + + +#endif // __wrappedlibglxnvidiaDEFS32_H_ diff --git a/src/wrapped32/generated/wrappedlibglxnvidiatypes32.h b/src/wrapped32/generated/wrappedlibglxnvidiatypes32.h new file mode 100644 index 000000000..699d359c4 --- /dev/null +++ b/src/wrapped32/generated/wrappedlibglxnvidiatypes32.h @@ -0,0 +1,73 @@ +/********************************************************************* + * File automatically generated by rebuild_wrappers_32.py (v0.0.2.2) * + *********************************************************************/ +#ifndef __wrappedlibglxnvidiaTYPES32_H_ +#define __wrappedlibglxnvidiaTYPES32_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + +typedef int32_t (*iFi_t)(int32_t); +typedef void* (*pFp_t)(void*); +typedef void (*vFip_t)(int32_t, void*); +typedef void (*vFpp_t)(void*, void*); +typedef int32_t (*iFpp_t)(void*, void*); +typedef void* (*pFXp_t)(void*, void*); +typedef void (*vFipp_t)(int32_t, void*, void*); +typedef void (*vFppp_t)(void*, void*, void*); +typedef void (*vFXpi_t)(void*, void*, int32_t); +typedef uint32_t (*uFuip_t)(uint32_t, int32_t, void*); +typedef void* (*pFXip_t)(void*, int32_t, void*); +typedef void (*vFuipu_t)(uint32_t, int32_t, void*, uint32_t); +typedef void (*vFuipp_t)(uint32_t, int32_t, void*, void*); +typedef void* (*pFXipp_t)(void*, int32_t, void*, void*); +typedef void* (*pFXppi_t)(void*, void*, void*, int32_t); +typedef void (*vFuippp_t)(uint32_t, int32_t, void*, void*, void*); +typedef void (*vFupupi_t)(uint32_t, void*, uint32_t, void*, int32_t); +typedef void (*vFuuippp_t)(uint32_t, uint32_t, int32_t, void*, void*, void*); +typedef void (*vFupupip_t)(uint32_t, void*, uint32_t, void*, int32_t, void*); +typedef void (*vFppupui_t)(void*, void*, uint32_t, void*, uint32_t, int32_t); + +#define SUPER() ADDED_FUNCTIONS() \ + GO(glXSwapIntervalMESA, iFi_t) \ + GO(glGetVkProcAddrNV, pFp_t) \ + GO(glXGetProcAddress, pFp_t) \ + GO(glXGetProcAddressARB, pFp_t) \ + GO(glVDPAUMapSurfacesNV, vFip_t) \ + GO(glVDPAUUnmapSurfacesNV, vFip_t) \ + GO(glDebugMessageCallback, vFpp_t) \ + GO(glDebugMessageCallbackAMD, vFpp_t) \ + GO(glDebugMessageCallbackARB, vFpp_t) \ + GO(glDebugMessageCallbackKHR, vFpp_t) \ + GO(eglDebugMessageControlKHR, iFpp_t) \ + GO(glXGetFBConfigFromVisualSGIX, pFXp_t) \ + GO(glXGetVisualFromFBConfig, pFXp_t) \ + GO(glXGetVisualFromFBConfigSGIX, pFXp_t) \ + GO(glProgramCallbackMESA, vFipp_t) \ + GO(eglSetBlobCacheFuncsANDROID, vFppp_t) \ + GO(glXSwapIntervalEXT, vFXpi_t) \ + GO(glCreateShaderProgramv, uFuip_t) \ + GO(glXChooseVisual, pFXip_t) \ + GO(glXGetFBConfigs, pFXip_t) \ + GO(glTransformFeedbackVaryings, vFuipu_t) \ + GO(glTransformFeedbackVaryingsEXT, vFuipu_t) \ + GO(glCompileShaderIncludeARB, vFuipp_t) \ + GO(glGetUniformIndices, vFuipp_t) \ + GO(glShaderSource, vFuipp_t) \ + GO(glShaderSourceARB, vFuipp_t) \ + GO(glXChooseFBConfig, pFXipp_t) \ + GO(glXChooseFBConfigSGIX, pFXipp_t) \ + GO(glXCreateContext, pFXppi_t) \ + GO(glBindVertexBuffers, vFuippp_t) \ + GO(glMultiDrawElements, vFupupi_t) \ + GO(glMultiDrawElementsEXT, vFupupi_t) \ + GO(glBindBuffersRange, vFuuippp_t) \ + GO(glVertexArrayVertexBuffers, vFuuippp_t) \ + GO(glMultiDrawElementsBaseVertex, vFupupip_t) \ + GO(glMultiModeDrawElementsIBM, vFppupui_t) + +#endif // __wrappedlibglxnvidiaTYPES32_H_ diff --git a/src/wrapped32/generated/wrappedlibglxnvidiaundefs32.h b/src/wrapped32/generated/wrappedlibglxnvidiaundefs32.h new file mode 100644 index 000000000..4b62be43f --- /dev/null +++ b/src/wrapped32/generated/wrappedlibglxnvidiaundefs32.h @@ -0,0 +1,8 @@ +/********************************************************************* + * File automatically generated by rebuild_wrappers_32.py (v0.0.2.2) * + *********************************************************************/ +#ifndef __wrappedlibglxnvidiaUNDEFS32_H_ +#define __wrappedlibglxnvidiaUNDEFS32_H_ + + +#endif // __wrappedlibglxnvidiaUNDEFS32_H_ diff --git a/src/wrapped32/wrappedlibegl.c b/src/wrapped32/wrappedlibegl.c index f0e8eb47b..d06bef7ab 100644 --- a/src/wrapped32/wrappedlibegl.c +++ b/src/wrapped32/wrappedlibegl.c @@ -24,12 +24,11 @@ static const char* libeglName = "libEGL.so.1"; #include "wrappercallback32.h" -void* getGLProcAddress32(x64emu_t* emu, glprocaddress_t procaddr, const char* rname); EXPORT void* my32_eglGetProcAddress(x64emu_t* emu, void* name) { khint_t k; const char* rname = (const char*)name; - return getGLProcAddress32(emu, (glprocaddress_t)my->eglGetProcAddress, rname); + return getGLProcAddress32(emu, NULL, (glprocaddress_t)my->eglGetProcAddress, rname); } #include "wrappedlib_init32.h" diff --git a/src/wrapped32/wrappedlibgl.c b/src/wrapped32/wrappedlibgl.c index 07a18b5c0..e4c1dd0fe 100644 --- a/src/wrapped32/wrappedlibgl.c +++ b/src/wrapped32/wrappedlibgl.c @@ -28,14 +28,13 @@ extern const char* libglName; void* getDisplay(void* d); // define in 32bits wrappedx11.c // FIXME: old wrapped* type of file, cannot use generated/wrappedlibgltypes.h -void* getGLProcAddress32(x64emu_t* emu, glprocaddress_t procaddr, const char* rname); EXPORT void* my32_glXGetProcAddress(x64emu_t* emu, void* name) { pFp_t fnc = getBridgeFnc2((void*)R_RIP); if(!fnc) fnc=my->glXGetProcAddress; khint_t k; const char* rname = (const char*)name; - return getGLProcAddress32(emu, (void*)fnc, rname); + return getGLProcAddress32(emu, NULL, (void*)fnc, rname); } EXPORT void* my32_glXGetProcAddressARB(x64emu_t* emu, void* name) __attribute__((alias("my32_glXGetProcAddress"))); @@ -541,8 +540,9 @@ gl_wrappers_t* getGLProcWrapper32(box64context_t* context, glprocaddress_t proca return wrappers; } -void* getGLProcAddress32(x64emu_t* emu, glprocaddress_t procaddr, const char* rname) +void* getGLProcAddress32(x64emu_t* emu, const char* my, glprocaddress_t procaddr, const char* rname) { + if(!my) my = "my32_"; khint_t k; printf_dlsym(LOG_DEBUG, "Calling getGLProcAddress32[%p](\"%s\") => ", procaddr, rname); gl_wrappers_t* wrappers = getGLProcWrapper32(emu->context, procaddr); @@ -555,7 +555,7 @@ void* getGLProcAddress32(x64emu_t* emu, glprocaddress_t procaddr, const char* rn if(is_my) { // try again, by using custom "my_" now... char tmp[200]; - strcpy(tmp, "my_"); + strcpy(tmp, my); strcat(tmp, rname); fnc = symbol; symbol = dlsym(emu->context->box64lib, tmp); diff --git a/src/wrapped32/wrappedlibglx.c b/src/wrapped32/wrappedlibglx.c index 4da58cc06..7dc37e1f6 100644 --- a/src/wrapped32/wrappedlibglx.c +++ b/src/wrapped32/wrappedlibglx.c @@ -40,7 +40,7 @@ EXPORT void* myx32_glXGetProcAddress(x64emu_t* emu, void* name) { khint_t k; const char* rname = (const char*)name; - return getGLProcAddress32(emu, (glprocaddress_t)my->glXGetProcAddress, rname); + return getGLProcAddress32(emu, NULL, (glprocaddress_t)my->glXGetProcAddress, rname); } EXPORT void* myx32_glXGetProcAddressARB(x64emu_t* emu, void* name) __attribute__((alias("myx32_glXGetProcAddress"))); diff --git a/src/wrapped32/wrappedlibglxnvidia.c b/src/wrapped32/wrappedlibglxnvidia.c new file mode 100644 index 000000000..57d1128a2 --- /dev/null +++ b/src/wrapped32/wrappedlibglxnvidia.c @@ -0,0 +1,504 @@ +#include +#include +#include +#define _GNU_SOURCE /* See feature_test_macros(7) */ +#include + +#include "wrappedlibs.h" + +#include "debug.h" +#include "wrapper32.h" +#include "bridge.h" +#include "librarian/library_private.h" +#include "x64emu.h" +#include "emu/x64emu_private.h" +#include "box32context.h" +#include "librarian.h" +#include "callback.h" +#include "gltools.h" +#include "libtools/my_x11_conv.h" + +static const char* libglxnvidiaName = "libGLX_nvidia.so.0"; +#define LIBNAME libglxnvidia +#define ALTMY my32nv_ + +#include "generated/wrappedlibgltypes32.h" + +#include "wrappercallback32.h" + +void* getDisplay(void* d); // define in 32bits wrappedx11.c + +// FIXME: old wrapped* type of file, cannot use generated/wrappedlibgltypes.h +EXPORT void* my32nv_glXGetProcAddress(x64emu_t* emu, void* name) +{ + pFp_t fnc = getBridgeFnc2((void*)R_RIP); + if(!fnc) fnc=my->glXGetProcAddress; + khint_t k; + const char* rname = (const char*)name; + return getGLProcAddress32(emu, "my32nv_" , (void*)fnc, rname); +} +EXPORT void* my32nv_glXGetProcAddressARB(x64emu_t* emu, void* name) __attribute__((alias("my32nv_glXGetProcAddress"))); + +typedef int (*iFi_t)(int); +typedef void (*vFpp_t)(void*, void*); +typedef void*(*pFpp_t)(void*, void*); +typedef void (*vFip_t)(int, void*); +typedef void (*vFppp_t)(void*, void*, void*); +typedef void (*vFppi_t)(void*, void*, int); +typedef void*(*pFpip_t)(void*, int, void*); +typedef void (*vFuip_t)(uint32_t, int, void*); +typedef void*(*pFp_t)(void*); +typedef void (*vFuipp_t)(uint32_t, int, void*, void*); +typedef void*(*pFpipp_t)(void*, int, void*, void*); +typedef void*(*pFpppi_t)(void*, void*, void*, int); +typedef void (*vFuipu_t)(uint32_t, int, void*, uint32_t); +typedef void (*vFupupi_t)(uint32_t, void*, uint32_t, void*, int); +typedef void (*vFuippp_t)(uint32_t, int, void*, void*, void*); +typedef void (*vFuuippp_t)(uint32_t, uint32_t, int, void*, void*, void*); +typedef void (*vFupupip_t)(uint32_t, void*, uint32_t, void*, int, void*); +typedef void (*vFppupui_t)(void*, void*, uint32_t, void*, uint32_t, int); +typedef void (*debugProc_t)(int32_t, int32_t, uint32_t, int32_t, int32_t, void*, void*); + +typedef struct gl_wrappers_s { + glprocaddress_t procaddress; + kh_symbolmap_t *glwrappers; // the map of wrapper for glProcs (for GLX or SDL1/2) + kh_symbolmap_t *glmymap; // link to the mysymbolmap of libGL +} gl_wrappers_t; + +KHASH_MAP_INIT_INT64(gl_wrappers, gl_wrappers_t*) + +static kh_gl_wrappers_t *gl_wrappers = NULL; + +#define SUPER() \ +GO(0) \ +GO(1) \ +GO(2) \ +GO(3) \ +GO(4) + +// debug_callback ... +#define GO(A) \ +static uintptr_t my_debug_callback_fct_##A = 0; \ +static void my_debug_callback_##A(int32_t a, int32_t b, uint32_t c, int32_t d, int32_t e, const char* f, const void* g) \ +{ \ + RunFunctionFmt(my_debug_callback_fct_##A, "iiuiipp", a, b, c, d, e, f, g); \ +} +SUPER() +#undef GO +static void* find_debug_callback_Fct(void* fct) +{ + if(!fct) return fct; + if(GetNativeFnc((uintptr_t)fct)) return GetNativeFnc((uintptr_t)fct); + #define GO(A) if(my_debug_callback_fct_##A == (uintptr_t)fct) return my_debug_callback_##A; + SUPER() + #undef GO + #define GO(A) if(my_debug_callback_fct_##A == 0) {my_debug_callback_fct_##A = (uintptr_t)fct; return my_debug_callback_##A; } + SUPER() + #undef GO + printf_log(LOG_NONE, "Warning, no more slot for libGL debug_callback callback\n"); + return NULL; +} +// egl_debug_callback ... +#define GO(A) \ +static uintptr_t my_egl_debug_callback_fct_##A = 0; \ + static void my_egl_debug_callback_##A(int a, void* b, int c, void* d, void* e, const char* f) \ +{ \ + RunFunctionFmt(my_egl_debug_callback_fct_##A, "ipippp", a, b, c, d, e, f); \ +} +SUPER() +#undef GO +static void* find_egl_debug_callback_Fct(void* fct) +{ + if(!fct) return fct; + if(GetNativeFnc((uintptr_t)fct)) return GetNativeFnc((uintptr_t)fct); + #define GO(A) if(my_egl_debug_callback_fct_##A == (uintptr_t)fct) return my_egl_debug_callback_##A; + SUPER() + #undef GO + #define GO(A) if(my_egl_debug_callback_fct_##A == 0) {my_egl_debug_callback_fct_##A = (uintptr_t)fct; return my_egl_debug_callback_##A; } + SUPER() + #undef GO + printf_log(LOG_NONE, "Warning, no more slot for libGL egl_debug_callback callback\n"); + return NULL; +} +// program_callback ... +#define GO(A) \ +static uintptr_t my_program_callback_fct_##A = 0; \ +static void my_program_callback_##A(int32_t a, void* b) \ +{ \ + RunFunctionFmt(my_program_callback_fct_##A, "ip", a, b); \ +} +SUPER() +#undef GO +static void* find_program_callback_Fct(void* fct) +{ + if(!fct) return fct; + if(GetNativeFnc((uintptr_t)fct)) return GetNativeFnc((uintptr_t)fct); + #define GO(A) if(my_program_callback_fct_##A == (uintptr_t)fct) return my_program_callback_##A; + SUPER() + #undef GO + #define GO(A) if(my_program_callback_fct_##A == 0) {my_program_callback_fct_##A = (uintptr_t)fct; return my_program_callback_##A; } + SUPER() + #undef GO + printf_log(LOG_NONE, "Warning, no more slot for libGL program_callback callback\n"); + return NULL; +} +// set_blob_func ... +#define GO(A) \ +static uintptr_t my_set_blob_func_fct_##A = 0; \ +static void my_set_blob_func_##A(void* a, ssize_t b, void* c, ssize_t d) \ +{ \ + RunFunctionFmt(my_set_blob_func_fct_##A, "plpl", a, b, c, d); \ +} +SUPER() +#undef GO +static void* find_set_blob_func_Fct(void* fct) +{ + if(!fct) return fct; + if(GetNativeFnc((uintptr_t)fct)) return GetNativeFnc((uintptr_t)fct); + #define GO(A) if(my_set_blob_func_fct_##A == (uintptr_t)fct) return my_set_blob_func_##A; + SUPER() + #undef GO + #define GO(A) if(my_set_blob_func_fct_##A == 0) {my_set_blob_func_fct_##A = (uintptr_t)fct; return my_set_blob_func_##A; } + SUPER() + #undef GO + printf_log(LOG_NONE, "Warning, no more slot for libGL set_blob_func callback\n"); + return NULL; +} +// get_blob_func ... +#define GO(A) \ +static uintptr_t my_get_blob_func_fct_##A = 0; \ +static ssize_t my_get_blob_func_##A(void* a, ssize_t b, void* c, ssize_t d) \ +{ \ + return (ssize_t)RunFunctionFmt(my_get_blob_func_fct_##A, "plpl", a, b, c, d); \ +} +SUPER() +#undef GO +static void* find_get_blob_func_Fct(void* fct) +{ + if(!fct) return fct; + if(GetNativeFnc((uintptr_t)fct)) return GetNativeFnc((uintptr_t)fct); + #define GO(A) if(my_get_blob_func_fct_##A == (uintptr_t)fct) return my_get_blob_func_##A; + SUPER() + #undef GO + #define GO(A) if(my_get_blob_func_fct_##A == 0) {my_get_blob_func_fct_##A = (uintptr_t)fct; return my_get_blob_func_##A; } + SUPER() + #undef GO + printf_log(LOG_NONE, "Warning, no more slot for libGL get_blob_func callback\n"); + return NULL; +} + +#undef SUPER + +#define PRE_INIT \ + if(BOX64ENV(libgl)) { \ + lib->w.lib = dlopen(BOX64ENV(libgl), RTLD_LAZY | RTLD_GLOBAL); \ + lib->path = strdup(BOX64ENV(libgl)); \ + } else if(strstr(lib->name, "libGLX_nvidia.so.0")) { \ + lib->w.lib = dlopen("libGLX_nvidia.so.0", RTLD_LAZY | RTLD_GLOBAL); \ + if(lib->w.lib) lib->path = strdup("libGLX_nvidia.so.0"); \ + } + +// glDebugMessageCallback ... +static void my32nv_glDebugMessageCallback(x64emu_t* emu, void* prod, void* param) +{ + vFpp_t fnc = getBridgeFnc2((void*)R_RIP); + if(!fnc) fnc=my->glDebugMessageCallback; + fnc(find_debug_callback_Fct(prod), param); +} +// glDebugMessageCallbackARB ... +static void my32nv_glDebugMessageCallbackARB(x64emu_t* emu, void* prod, void* param) +{ + vFpp_t fnc = getBridgeFnc2((void*)R_RIP); + if(!fnc) fnc=my->glDebugMessageCallbackARB; + fnc(find_debug_callback_Fct(prod), param); +} +// glDebugMessageCallbackAMD ... +static void my32nv_glDebugMessageCallbackAMD(x64emu_t* emu, void* prod, void* param) +{ + vFpp_t fnc = getBridgeFnc2((void*)R_RIP); + if(!fnc) fnc=my->glDebugMessageCallbackAMD; + fnc(find_debug_callback_Fct(prod), param); +} +// glDebugMessageCallbackKHR ... +static void my32nv_glDebugMessageCallbackKHR(x64emu_t* emu, void* prod, void* param) +{ + vFpp_t fnc = getBridgeFnc2((void*)R_RIP); + if(!fnc) fnc=my->glDebugMessageCallbackKHR; + fnc(find_debug_callback_Fct(prod), param); +} +// eglDebugMessageControlKHR ... +static int my_eglDebugMessageControlKHR(x64emu_t* emu, void* prod, void* param) +{ + iFpp_t fnc = getBridgeFnc2((void*)R_RIP); + if(!fnc) fnc=my->eglDebugMessageControlKHR; + return fnc(find_egl_debug_callback_Fct(prod), param); +} +// eglSetBlobCacheFuncsANDROID ... +static void my_eglSetBlobCacheFuncsANDROID(x64emu_t* emu, void* dpy, void* set, void* get) +{ + vFppp_t fnc = getBridgeFnc2((void*)R_RIP); + if(!fnc) fnc=my->eglSetBlobCacheFuncsANDROID; + fnc(dpy, find_set_blob_func_Fct(set), find_get_blob_func_Fct(get)); +} +// glXSwapIntervalMESA ... +static int my32nv_dummy_glXSwapIntervalMESA(int interval) +{ + return 5; // GLX_BAD_CONTEXT +} +static int my32nv_glXSwapIntervalMESA(x64emu_t* emu, int interval) +{ + iFi_t fnc = getBridgeFnc2((void*)R_RIP); + if(!fnc) fnc=my->glXSwapIntervalMESA; + if(!fnc) fnc=my32nv_dummy_glXSwapIntervalMESA; + return fnc(interval); +} +// glXSwapIntervalEXT ... +static void my32nv_dummy_glXSwapIntervalEXT(void* dpy, void* drawable, int interval) {} +static void my32nv_glXSwapIntervalEXT(x64emu_t* emu, void* dpy, void* drawable, int interval) +{ + vFppi_t fnc = getBridgeFnc2((void*)R_RIP); + if(!fnc) fnc=my->glXSwapIntervalEXT; + if(!fnc) fnc=my32nv_dummy_glXSwapIntervalEXT; + fnc(dpy, drawable, interval); +} + +// glProgramCallbackMESA ... +static void my32nv_glProgramCallbackMESA(x64emu_t* emu, int t, void* f, void* data) +{ + vFipp_t fnc = getBridgeFnc2((void*)R_RIP); + if(!fnc) fnc=my->glProgramCallbackMESA; + fnc(t, find_program_callback_Fct(f), data); +} + +void* my_GetVkProcAddr(x64emu_t* emu, void* name, void*(*getaddr)(void*)); // defined in wrappedvulkan.c +// glGetVkProcAddrNV ... +static void* my32nv_glGetVkProcAddrNV(x64emu_t* emu, void* name) +{ + pFp_t fnc = getBridgeFnc2((void*)R_RIP); + if(!fnc) fnc=my->glGetVkProcAddrNV; + return my_GetVkProcAddr(emu, name, fnc); +} +// glShaderSource ... +static void my32nv_glShaderSource(x64emu_t* emu, uint32_t shader, int count, ptr_t* string, int* length) +{ + vFuipp_t fnc = getBridgeFnc2((void*)R_RIP); + if(!fnc) fnc=my->glShaderSource; + char* str[count]; + if(string) for(int i=0; iglXChooseFBConfig; + void** res = fnc(dpy, screen, list, nelement); + if(!res) + return NULL; + ptr_t* fbconfig = (ptr_t*)res; + for(int i=0; i<*nelement; ++i) + fbconfig[i] = to_ptrv(res[i]); + return res; +} +// glXChooseFBConfigSGIX ... +EXPORT void* my32nv_glXChooseFBConfigSGIX(x64emu_t* emu, void* dpy, int screen, int* list, int* nelement) +{ + pFpipp_t fnc = getBridgeFnc2((void*)R_RIP); + if(!fnc) fnc=my->glXChooseFBConfigSGIX; + void** res = fnc(dpy, screen, list, nelement); + if(!res) + return NULL; + ptr_t* fbconfig = (ptr_t*)res; + for(int i=0; i<*nelement; ++i) + fbconfig[i] = to_ptrv(res[i]); + return res; +} +// glXGetVisualFromFBConfig ... +EXPORT void* my32nv_glXGetVisualFromFBConfig(x64emu_t* emu, void* dpy, void* config) +{ + pFpp_t fnc = getBridgeFnc2((void*)R_RIP); + if(!fnc) fnc=my->glXGetVisualFromFBConfig; + void* res = fnc(dpy, config); + if(!res) + return NULL; + my_XVisualInfo_32_t* vinfo = (my_XVisualInfo_32_t*)res; + convert_XVisualInfo_to_32(dpy, vinfo, res); + return vinfo; +} +// glXGetVisualFromFBConfigSGIX ... +EXPORT void* my32nv_glXGetVisualFromFBConfigSGIX(x64emu_t* emu, void* dpy, void* config) +{ + pFpp_t fnc = getBridgeFnc2((void*)R_RIP); + if(!fnc) fnc=my->glXGetVisualFromFBConfigSGIX; + void* res = fnc(dpy, config); + if(!res) + return NULL; + my_XVisualInfo_32_t* vinfo = (my_XVisualInfo_32_t*)res; + convert_XVisualInfo_to_32(dpy, vinfo, res); + return vinfo; +} +// glXChooseVisual ... +EXPORT void* my32nv_glXChooseVisual(x64emu_t* emu, void* dpy, int screen, int* attr) +{ + pFpip_t fnc = getBridgeFnc2((void*)R_RIP); + if(!fnc) fnc=my->glXChooseVisual; + void* res = fnc(dpy, screen, attr); + my_XVisualInfo_32_t* vinfo = (my_XVisualInfo_32_t*)res; + convert_XVisualInfo_to_32(dpy, vinfo, res); + return vinfo; +} +// glXCreateContext ... +EXPORT void* my32nv_glXCreateContext(x64emu_t* emu, void* dpy, my_XVisualInfo_32_t* info, void* shared, int direct) +{ + pFpppi_t fnc = getBridgeFnc2((void*)R_RIP); + if(!fnc) fnc=my->glXCreateContext; + my_XVisualInfo_t info_l = {0}; + convert_XVisualInfo_to_64(dpy, &info_l, info); + return fnc(dpy, &info_l, shared, direct); +} +// glXGetFBConfigFromVisualSGIX ... +EXPORT void* my32nv_glXGetFBConfigFromVisualSGIX(x64emu_t* emu, void* dpy, my_XVisualInfo_32_t* info) +{ + pFpp_t fnc = getBridgeFnc2((void*)R_RIP); + if(!fnc) fnc=my->glXGetFBConfigFromVisualSGIX; + my_XVisualInfo_t info_l = {0}; + convert_XVisualInfo_to_64(dpy, &info_l, info); + return fnc(dpy, &info_l); +} +// glMultiDrawElements ... +EXPORT void my32nv_glMultiDrawElements(x64emu_t* emu, uint32_t mode, void* count, uint32_t type, ptr_t* indices, int drawcount) +{ + vFupupi_t fnc = getBridgeFnc2((void*)R_RIP); + if(!fnc) fnc=my->glMultiDrawElements; + void* indices_l[drawcount]; + for(int i=0; iglMultiModeDrawElementsIBM; + void* indices_l[primcount]; + for(uint32_t i=0; iglTransformFeedbackVaryings; + void* varyings_l[count]; + for(int i=0; iglBindBuffersRange; + long offsets_l[count]; + long sizes_l[count]; + for(int i=0; iglBindVertexBuffers; + long offsets_l[count]; + for(int i=0; iglVertexArrayVertexBuffers; + long offsets_l[count]; + for(int i=0; iglMultiDrawElementsBaseVertex; + void* indices_l[drawcount]; + for(int i=0; iglCreateShaderProgramv; + char* str[count]; + if(string) for(int i=0; iglCompileShaderIncludeARB; + char* str[count]; + if(string) for(int i=0; iglXGetFBConfigs; + void* ret = fnc(dpy, screen, n); + if(!ret) return NULL; + void** src = ret; + ptr_t* dst = ret; + for(int i=0; i<*n; ++i) + dst[i] = to_ptrv(src[i]); + return ret; +} +// glGetUniformIndices ... +EXPORT void my32nv_glGetUniformIndices(x64emu_t* emu, uint32_t prog, int count, ptr_t* names, void* indices) +{ + vFuipp_t fnc = getBridgeFnc2((void*)R_RIP); + if(!fnc) fnc=my->glGetUniformIndices; + void* names_l[count]; + fnc(prog, count, names?names_l:NULL, indices); + if(names) for(int i=0; iglVDPAUMapSurfacesNV; + long surfaces_l[count]; + if(surfaces) for(int i=0; iglVDPAUUnmapSurfacesNV; + long surfaces_l[count]; + if(surfaces) for(int i=0; iSDL_GL_GetProcAddress, rname); + return getGLProcAddress32(emu, NULL, (glprocaddress_t)my->SDL_GL_GetProcAddress, rname); } // DL functions from wrappedlibdl.c diff --git a/src/wrapped32/wrappedsdl2.c b/src/wrapped32/wrappedsdl2.c index e96dedae0..e4a65919f 100644 --- a/src/wrapped32/wrappedsdl2.c +++ b/src/wrapped32/wrappedsdl2.c @@ -330,7 +330,7 @@ EXPORT void* my32_2_SDL_GL_GetProcAddress(x64emu_t* emu, void* name) { khint_t k; const char* rname = (const char*)name; - return getGLProcAddress32(emu, (glprocaddress_t)my->SDL_GL_GetProcAddress, rname); + return getGLProcAddress32(emu, NULL, (glprocaddress_t)my->SDL_GL_GetProcAddress, rname); } EXPORT void* my32_2_SDL_CreateRGBSurfaceWithFormatFrom(x64emu_t* emu, void* pixels, int width, int height, int depth, int pitch, uint32_t format)