diff --git a/JavaApp/src/main/java/net/kdt/pojavlaunch/PLaunchApp.java b/JavaApp/src/main/java/net/kdt/pojavlaunch/PLaunchApp.java index 2c8e6e98..f74e9a2a 100644 --- a/JavaApp/src/main/java/net/kdt/pojavlaunch/PLaunchApp.java +++ b/JavaApp/src/main/java/net/kdt/pojavlaunch/PLaunchApp.java @@ -97,7 +97,7 @@ public class PLaunchApp { if (AccountJNI.CURRENT_ACCOUNT.accessToken.equals("0")) { if (!new File(verJsonDir).exists()) { // Local account: disallow install new version - UIKit.showError("Error", "Minecraft can't be legally installed when logged in with a local account. Please switch to paid account to continue.", false); + UIKit.showError("Error", "Minecraft can't be legally installed when logged in with a local account. Please switch to Mojang/Microsoft account to continue.", false); return; } else { // Local account: jump to launch Minecraft, not download anything diff --git a/Natives/CMakeLists.txt b/Natives/CMakeLists.txt index db5f3a72..709aad0d 100644 --- a/Natives/CMakeLists.txt +++ b/Natives/CMakeLists.txt @@ -1,7 +1,7 @@ cmake_minimum_required(VERSION 3.6) project(PojavLauncher) -set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fcommon -fobjc-arc -ObjC -I'${CMAKE_CURRENT_LIST_DIR}/resources/Frameworks/MetalANGLE.framework/Headers' -I'${CMAKE_CURRENT_LIST_DIR}/external/DBNumberedSlider/Classes' -I'${CMAKE_CURRENT_LIST_DIR}/external/fishhook'" +set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fcommon -fobjc-arc -ObjC -I'${CMAKE_CURRENT_LIST_DIR}/resources/Frameworks/MetalANGLE.framework/Headers' -I'${CMAKE_CURRENT_LIST_DIR}/external/DBNumberedSlider/Classes' -I'${CMAKE_CURRENT_LIST_DIR}/external/fishhook' -I'${CMAKE_CURRENT_LIST_DIR}/external_include'" ) set(CMAKE_C_FLAGS_DEBUG "-funwind-tables -g") @@ -54,10 +54,11 @@ add_library(pojavexec SHARED ) target_link_libraries(pojavexec "-F'${CMAKE_CURRENT_LIST_DIR}/resources/Frameworks'" - "-framework UIKit" - "-framework MetalANGLE" - "-framework CoreGraphics" "-framework AuthenticationServices" + "-framework CoreGraphics" + "-framework MetalANGLE" + "-framework QuartzCore" + "-framework UIKit" ) add_executable(PojavLauncher diff --git a/Natives/JavaGUIViewController.m b/Natives/JavaGUIViewController.m index dcf13044..492e3ff5 100644 --- a/Natives/JavaGUIViewController.m +++ b/Natives/JavaGUIViewController.m @@ -19,12 +19,9 @@ JNIEXPORT void JNICALL Java_net_kdt_pojavlaunch_uikit_UIKit_refreshAWTBuffer(JNI } @implementation SurfaceView -const void * _CGDataProviderGetBytePointerCallback(void *info) { +const void * _CGDataProviderGetBytePointerCallbackAWT(void *info) { return (const void *)rgbArray; } - -void _CGDataProviderReleaseBytePointerCallback(void *info,const void *pointer) { -} - (void)displayLayer:(CALayer *)theLayer { @@ -46,7 +43,7 @@ void _CGDataProviderReleaseBytePointerCallback(void *info,const void *pointer) { colorSpace = CGColorSpaceCreateDeviceRGB(); callbacks.version = 0; - callbacks.getBytePointer = _CGDataProviderGetBytePointerCallback; + callbacks.getBytePointer = _CGDataProviderGetBytePointerCallbackAWT; callbacks.releaseBytePointer = _CGDataProviderReleaseBytePointerCallback; callbacks.getBytesAtPosition = NULL; callbacks.releaseInfo = NULL; diff --git a/Natives/JavaLauncher.m b/Natives/JavaLauncher.m index 548d06a4..6ae2193c 100644 --- a/Natives/JavaLauncher.m +++ b/Natives/JavaLauncher.m @@ -370,7 +370,6 @@ int launchJVM(int argc, char *argv[]) { javaHome = calloc(1, 2048); sprintf((char *)javaHome, "%s/jre", homeDir); } - setenv("JAVA_HOME", javaHome, 1); debug("[Pre-init] JAVA_HOME environment variable was not set. Defaulting to %s for future use.\n", javaHome); } else { if (0 == [[NSFileManager defaultManager] fileExistsAtPath:javaHome_pre]) { @@ -389,6 +388,7 @@ int launchJVM(int argc, char *argv[]) { debug("[Pre-Init] Restored preference: JAVA_HOME is set to %s\n", javaHome); } } + setenv("JAVA_HOME", javaHome, 1); if (!started && strncmp(argv[0], "/Applications", 13)) { char src[2048], dst[2048]; @@ -491,10 +491,11 @@ int launchJVM(int argc, char *argv[]) { allocmem_pre = [getPreference(@"allocated_memory") stringValue]; allocmem = [allocmem_pre cStringUsingEncoding:NSUTF8StringEncoding]; - char controlPath[2048]; + char *controlPath = calloc(1, 2048); sprintf(controlPath, "%s/controlmap", homeDir); mkdir(controlPath, S_IRWXU | S_IRWXG | S_IRWXO); setenv("POJAV_PATH_CONTROL", controlPath, 1); + free(controlPath); generateAndSaveDefaultControl(); char classpath[10000]; @@ -532,7 +533,7 @@ int launchJVM(int argc, char *argv[]) { snprintf(librarySym, 2048, "%s/Library/Application Support/minecraft", getenv("POJAV_HOME")); remove(librarySym); symlink(multidir_char, librarySym); - setenv("POJAV_GAME_DIR", multidir_char, 1); + setenv("POJAV_GAME_DIR", librarySym, 1); char *oldGameDir = calloc(1, 2048); snprintf(oldGameDir, 2048, "%s/Documents/minecraft", getenv("HOME")); @@ -563,7 +564,7 @@ int launchJVM(int argc, char *argv[]) { NSLog(@"[Pre-init] Java executable path: %s", javaPath); setenv("JAVA_EXT_EXECNAME", javaPath, 1); - chdir(userDir); + chdir(librarySym); margv[margc++] = javaPath; margv[margc++] = "-XstartOnFirstThread"; @@ -641,6 +642,12 @@ int launchJVM(int argc, char *argv[]) { return -2; } + // Free unused char arrays + free(librarySym); + free(multidir_char); + free(oldGameDir); + free(oldLibraryDir); + debug("[Init] Calling JLI_Launch"); /* for (int i = 0; i < margc; i++) { diff --git a/Natives/LauncherPreferencesViewController.m b/Natives/LauncherPreferencesViewController.m index e74c6990..a1bf691d 100644 --- a/Natives/LauncherPreferencesViewController.m +++ b/Natives/LauncherPreferencesViewController.m @@ -43,9 +43,10 @@ UISwitch *noshaderconvSwitch; UIBlurEffect *blur; UIVisualEffectView *blurView; UIScrollView *scrollView; -NSString *gl4es114 = @"GL4ES 1.1.4"; -NSString *gl4es115 = @"GL4ES 1.1.5 (1.16+)"; -NSString *tinygl4angle = @"tinygl4angle (1.17+)"; +NSString *gl4es114 = @"GL4ES 1.1.4 - exports OpenGL 2.1"; +NSString *gl4es115 = @"GL4ES 1.1.5 (1.16+) - exports OpenGL 2.1"; +NSString *tinygl4angle = @"tinygl4angle (1.17+) - exports OpenGL 3.2 (Core Profile, limited)"; +NSString *zink = @"Zink (Mesa 21.2.1) - exports OpenGL 4.6"; NSString *java8jben = @"Java 8"; NSString *java16jben = @"Java 16"; NSString *java17jben = @"Java 17"; @@ -54,11 +55,10 @@ NSString *libsjava8jben = @"/usr/lib/jvm/java-8-openjdk"; NSString *libsjava16jben = @"/usr/lib/jvm/java-16-openjdk"; NSString *libsjava17jben = @"/usr/lib/jvm/java-17-openjdk"; NSString *libsjava8; -//NSString *vgpu = @"vgpu"; NSString *lib_gl4es114 = @"libgl4es_114.dylib"; NSString *lib_gl4es115 = @"libgl4es_115.dylib"; NSString *lib_tinygl4angle = @"libtinygl4angle.dylib"; -//NSString *lib_vgpu = @"libvgpu.dylib"; +NSString *lib_zink = @"libOSMesa.8.dylib"; - (void)viewDidLoad { @@ -194,9 +194,9 @@ NSString *lib_tinygl4angle = @"libtinygl4angle.dylib"; rendTextField.text = gl4es115; } else if ([getPreference(@"renderer") isEqualToString:lib_tinygl4angle]) { rendTextField.text = tinygl4angle; - } /* else if ([getPreference(@"renderer") isEqualToString:lib_vgpu) { - rendTextField.text = vgpu; - }*/ + } else if ([getPreference(@"renderer") isEqualToString:lib_zink]) { + rendTextField.text = zink; + } rendTextField.contentVerticalAlignment = UIControlContentVerticalAlignmentTop; rendTextField.contentHorizontalAlignment = UIControlContentHorizontalAlignmentLeft; @@ -206,7 +206,7 @@ NSString *lib_tinygl4angle = @"libtinygl4angle.dylib"; [rendererList addObject:gl4es114]; [rendererList addObject:gl4es115]; [rendererList addObject:tinygl4angle]; - //[rendererList addObject:vgpu]; + //[rendererList addObject:zink]; //TODO [self instanceDirCont]; @@ -509,17 +509,14 @@ NSString *lib_tinygl4angle = @"libtinygl4angle.dylib"; } else if (textField.tag == 102) { if ([textField.text isEqualToString:gl4es114]) { setPreference(@"renderer", lib_gl4es114); - setenv("RENDERER", [lib_gl4es114 cStringUsingEncoding:NSUTF8StringEncoding], 1); } else if ([textField.text isEqualToString:gl4es115]) { setPreference(@"renderer", lib_gl4es115); - setenv("RENDERER", [lib_gl4es115 cStringUsingEncoding:NSUTF8StringEncoding], 1); } else if ([textField.text isEqualToString:tinygl4angle]) { setPreference(@"renderer", lib_tinygl4angle); - setenv("RENDERER", [lib_tinygl4angle cStringUsingEncoding:NSUTF8StringEncoding], 1); - } /* else if ([textField.text isEqualToString:vgpu]) { - setPreference(@"renderer", lib_vgpu); - setenv("RENDERER", [lib_vgpu cStringUsingEncoding:NSUTF8StringEncoding]]), 1); - } */ + } else if ([textField.text isEqualToString:zink]) { + setPreference(@"renderer", lib_zink); + } + setenv("RENDERER", [getPreference(@"renderer") UTF8String], 1); if (![textField.text isEqualToString:gl4es115] && [getPreference(@"disable_gl4es_shaderconv") boolValue] == YES) { setPreference(@"disable_gl4es_shaderconv", @NO); @@ -868,7 +865,6 @@ NSString *lib_tinygl4angle = @"libtinygl4angle.dylib"; - (void)pickerView:(UIPickerView *)pickerView didSelectRow:(NSInteger)row inComponent:(NSInteger)component { if(pickerView.tag == 112) { rendTextField.text = [self pickerView:pickerView titleForRow:row forComponent:component]; - setPreference(@"renderer", rendTextField.text); } else if(pickerView.tag == 113) { jhomeTextField.text = [self pickerView:pickerView titleForRow:row forComponent:component]; setPreference(@"java_home", jhomeTextField.text); diff --git a/Natives/LauncherViewController.m b/Natives/LauncherViewController.m index 85f470bb..3099de11 100644 --- a/Natives/LauncherViewController.m +++ b/Natives/LauncherViewController.m @@ -271,6 +271,7 @@ int versionSelectedAt = 0; } else { result = [object valueForKey:@"url"]; } + NSAssert(result != nil, @"version should not be null"); callback_LauncherViewController_installMinecraft([result UTF8String]); } diff --git a/Natives/LoginViewController.m b/Natives/LoginViewController.m index 550a6d48..90881ec4 100644 --- a/Natives/LoginViewController.m +++ b/Natives/LoginViewController.m @@ -381,7 +381,7 @@ void loginAccountInput(UINavigationController *controller, int type, const char* NSString *out_username = [selectedProfile valueForKey:@"name"]; NSLog(@"DBG: Login succeed: %@, %@, %@, %@", out_accessToken, out_clientToken, out_profileID, out_username); */ - assert(dataStr != nil); + NSAssert(dataStr != nil, @"account data should not be null"); loginAccountInput(self.navigationController, TYPE_MOJANG, [dataStr UTF8String]); } } else { diff --git a/Natives/SurfaceViewController.h b/Natives/SurfaceViewController.h index 69673225..504e06bd 100644 --- a/Natives/SurfaceViewController.h +++ b/Natives/SurfaceViewController.h @@ -1,11 +1,17 @@ #import +#import #import "MGLKit.h" @interface GameSurfaceView : UIView +{ +CALayer* layer; +CGColorSpaceRef colorSpace; +CGDataProviderDirectCallbacks callbacks; +} @end @interface SurfaceViewController : UIViewController -// MGLKViewController -// UIViewController + +@property(nonatomic, strong) UIView* surfaceView; @end diff --git a/Natives/SurfaceViewController.m b/Natives/SurfaceViewController.m index b6f71474..ef5fa738 100644 --- a/Natives/SurfaceViewController.m +++ b/Natives/SurfaceViewController.m @@ -36,19 +36,52 @@ int notchOffset; // TODO: key modifiers impl @implementation GameSurfaceView +const void * _CGDataProviderGetBytePointerCallbackOSMESA(void *info) { + return gbuffer; +} + +- (void)displayLayer:(CALayer *)theLayer +{ + CGDataProviderRef bitmapProvider = CGDataProviderCreateDirect(NULL, savedWidth * savedHeight * 4, &callbacks); + CGImageRef bitmap = CGImageCreate(savedWidth, savedHeight, 8, 32, 4 * savedWidth, colorSpace, kCGImageAlphaNoneSkipLast | kCGBitmapByteOrder16Little, bitmapProvider, NULL, FALSE, kCGRenderingIntentDefault); + + theLayer.contents = (__bridge id) bitmap; + CGImageRelease(bitmap); + CGDataProviderRelease(bitmapProvider); + // CGColorSpaceRelease(colorSpace); +} + - (id)initWithFrame:(CGRect)frame { - return self = [super initWithFrame:frame]; + self = [super initWithFrame:frame]; + + if ([@(getenv("RENDERER")) hasPrefix:@"libOSMesa"]) { + layer = [self layer]; + layer.opaque = YES; + + colorSpace = CGColorSpaceCreateDeviceRGB(); + + callbacks.version = 0; + callbacks.getBytePointer = _CGDataProviderGetBytePointerCallbackOSMESA; + callbacks.releaseBytePointer = _CGDataProviderReleaseBytePointerCallback; + callbacks.getBytesAtPosition = NULL; + callbacks.releaseInfo = NULL; + } + + return self; } + (Class)layerClass { - return MGLLayer.class; + if ([@(getenv("RENDERER")) hasPrefix:@"libOSMesa"]) { + return CALayer.class; + } else { + return CAMetalLayer.class; + } } @end @interface SurfaceViewController () { } -@property(nonatomic, strong) UIView* surfaceView; @property(nonatomic, strong) NSMutableDictionary* cc_dictionary; @property(nonatomic, strong) NSMutableArray* swipeableButtons; @property(nonatomic, strong) NSMutableArray* togglableVisibleButtons; @@ -211,18 +244,8 @@ int notchOffset; [self executebtn_special_togglebtn:0]; - ((MGLLayer *)self.surfaceView.layer).drawableDepthFormat = MGLDrawableDepthFormat24; // [self setPreferredFramesPerSecond:1000]; - // Init GLES - sharegroup = [[MGLSharegroup alloc] init]; - firstContext = [[MGLContext alloc] initWithAPI:kMGLRenderingAPIOpenGLES3 sharegroup:sharegroup]; - if (!firstContext) { - NSLog(@"Failed to create ES context"); - } - - [MGLContext setCurrentContext:firstContext forLayer:(MGLLayer *)self.surfaceView.layer]; - [self setupGL]; } diff --git a/Natives/egl_bridge.m b/Natives/egl_bridge.m index f9d6c1a8..3a9170b7 100644 --- a/Natives/egl_bridge.m +++ b/Natives/egl_bridge.m @@ -8,15 +8,20 @@ #include #include -#include "egl_bridge.h" - #include "EGL/egl.h" +#include "EGL/eglext.h" +#include "GL/osmesa.h" #include "GLES2/gl2.h" -#include "utils.h" +#include "egl_bridge.h" +#include "osmesa_internal.h" #include "log.h" +#include "utils.h" +// region OSMESA internals + +// endregion OSMESA internals struct PotatoBridge { /* EGLContext */ void* eglContextOld; /* EGLContext */ void* eglContext; @@ -28,22 +33,60 @@ struct PotatoBridge { */ }; EGLConfig config; -mach_port_t mainThreadID; +pid_t mainThreadID; struct PotatoBridge potatoBridge; +/* OSMesa functions */ +GLboolean (*OSMesaMakeCurrent_p) (OSMesaContext ctx, void *buffer, GLenum type, + GLsizei width, GLsizei height); +OSMesaContext (*OSMesaGetCurrentContext_p) (void); +OSMesaContext (*OSMesaCreateContext_p) (GLenum format, OSMesaContext sharelist); +void (*OSMesaDestroyContext_p) (OSMesaContext ctx); +void (*OSMesaPixelStore_p) ( GLint pname, GLint value ); +GLubyte* (*glGetString_p) (GLenum name); +void (*glFinish_p) (void); +void (*glClearColor_p) (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); +void (*glClear_p) (GLbitfield mask); + +/*EGL functions */ +EGLBoolean (*eglMakeCurrent_p) (EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx); +EGLBoolean (*eglDestroyContext_p) (EGLDisplay dpy, EGLContext ctx); +EGLBoolean (*eglDestroySurface_p) (EGLDisplay dpy, EGLSurface surface); +EGLBoolean (*eglTerminate_p) (EGLDisplay dpy); +EGLBoolean (*eglReleaseThread_p) (void); +EGLContext (*eglGetCurrentContext_p) (void); +EGLDisplay (*eglGetPlatformDisplay_p) (EGLenum platform, void *native_display, const EGLint *attrib_list); +EGLBoolean (*eglInitialize_p) (EGLDisplay dpy, EGLint *major, EGLint *minor); +EGLBoolean (*eglChooseConfig_p) (EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config); +EGLBoolean (*eglGetConfigAttrib_p) (EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value); +EGLBoolean (*eglBindAPI_p) (EGLenum api); +EGLSurface (*eglCreateWindowSurface_p) (EGLDisplay dpy, EGLConfig config, NativeWindowType window, const EGLint *attrib_list); +EGLBoolean (*eglSwapBuffers_p) (EGLDisplay dpy, EGLSurface draw); +EGLint (*eglGetError_p) (void); +EGLContext (*eglCreateContext_p) (EGLDisplay dpy, EGLConfig config, EGLContext share_list, const EGLint *attrib_list); +EGLBoolean (*eglSwapInterval_p) (EGLDisplay dpy, EGLint interval); +EGLSurface (*eglGetCurrentSurface_p) (EGLint readdraw); +#define RENDERER_MTL_ANGLE 1 +#define RENDERER_VK_ZINK 2 + +int config_renderer; + typedef void gl4esInitialize_func(); // typedef void gl4esSwapBuffers_func(); // gl4esSwapBuffers_func *gl4esSwapBuffers; typedef jint RegalMakeCurrent_func(EGLContext context); -// Called from JNI_OnLoad of liblwjgl_opengl +// Called from JNI_OnLoad of liblwjgl_opengl, TODO: check if unused void pojav_openGLOnLoad() { - } void pojav_openGLOnUnload() { - } +pid_t gettid() { + return (pid_t) pthread_mach_thread_np(pthread_self()); +} + + JNIEXPORT void JNICALL Java_net_kdt_pojavlaunch_utils_JREUtils_setenv(JNIEnv *env, jclass clazz, jstring name, jstring value, jboolean overwrite) { char const *name_c = (*env)->GetStringUTFChars(env, name, NULL); char const *value_c = (*env)->GetStringUTFChars(env, value, NULL); @@ -55,106 +98,353 @@ JNIEXPORT void JNICALL Java_net_kdt_pojavlaunch_utils_JREUtils_setenv(JNIEnv *en } JNIEXPORT void JNICALL Java_net_kdt_pojavlaunch_utils_JREUtils_saveGLContext(JNIEnv* env, jclass clazz) { - potatoBridge.eglContext = eglGetCurrentContext(); - potatoBridge.eglDisplay = eglGetCurrentDisplay(); - potatoBridge.eglSurface = eglGetCurrentSurface(EGL_DRAW); - // eglMakeCurrent(potatoBridge.eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); + // @deprecated, remove later } void terminateEgl() { debug("EGLBridge: Terminating"); - [MGLContext setCurrentContext:nil]; - - potatoBridge.eglContext = EGL_NO_CONTEXT; - potatoBridge.eglDisplay = EGL_NO_DISPLAY; - potatoBridge.eglSurface = EGL_NO_SURFACE; + switch (config_renderer) { + case RENDERER_MTL_ANGLE: { + eglMakeCurrent_p(potatoBridge.eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); + eglDestroySurface_p(potatoBridge.eglDisplay, potatoBridge.eglSurface); + eglDestroyContext_p(potatoBridge.eglDisplay, potatoBridge.eglContext); + eglTerminate_p(potatoBridge.eglDisplay); + eglReleaseThread_p(); + + potatoBridge.eglContext = EGL_NO_CONTEXT; + potatoBridge.eglDisplay = EGL_NO_DISPLAY; + potatoBridge.eglSurface = EGL_NO_SURFACE; + } break; + + case RENDERER_VK_ZINK: { + // Nothing to do here + } break; + } } JNIEXPORT jlong JNICALL Java_org_lwjgl_glfw_GLFW_nativeEglGetCurrentContext(JNIEnv* env, jclass clazz) { - return (jlong) eglGetCurrentContext(); + switch (config_renderer) { + case RENDERER_MTL_ANGLE: + return (jlong) eglGetCurrentContext_p(); + + case RENDERER_VK_ZINK: + return (jlong) OSMesaGetCurrentContext_p(); + + default: return (jlong) 0; + } +} + +void loadSymbols() { + char fileName[2048]; + switch (config_renderer) { + case RENDERER_VK_ZINK: + sprintf((char *)fileName, "%s/Frameworks/libOSMesa.8.dylib.framework/libOSMesa.8.dylib", getenv("BUNDLE_PATH")); + break; + case RENDERER_MTL_ANGLE: + sprintf((char *)fileName, "%s/Frameworks/MetalANGLE.framework/MetalANGLE", getenv("BUNDLE_PATH")); + break; + } + void* dl_handle = dlopen(fileName,RTLD_NOW|RTLD_GLOBAL|RTLD_NODELETE); + + if(dl_handle == NULL) { + NSLog(@"DlLoader: unable to load: %s", dlerror()); + return; + } + switch(config_renderer) { + case RENDERER_VK_ZINK: + OSMesaMakeCurrent_p = dlsym(dl_handle,"OSMesaMakeCurrent"); + OSMesaGetCurrentContext_p = dlsym(dl_handle,"OSMesaGetCurrentContext"); + OSMesaCreateContext_p = dlsym(dl_handle, "OSMesaCreateContext"); + OSMesaDestroyContext_p = dlsym(dl_handle, "OSMesaDestroyContext"); + OSMesaPixelStore_p = dlsym(dl_handle,"OSMesaPixelStore"); + glGetString_p = dlsym(dl_handle,"glGetString"); + glClearColor_p = dlsym(dl_handle, "glClearColor"); + glClear_p = dlsym(dl_handle,"glClear"); + glFinish_p = dlsym(dl_handle,"glFinish"); + break; + case RENDERER_MTL_ANGLE: + eglBindAPI_p = dlsym(dl_handle,"eglBindAPI"); + eglChooseConfig_p = dlsym(dl_handle, "eglChooseConfig"); + eglCreateContext_p = dlsym(dl_handle, "eglCreateContext"); + eglCreateWindowSurface_p = dlsym(dl_handle, "eglCreateWindowSurface"); + eglDestroyContext_p = dlsym(dl_handle, "eglDestroyContext"); + eglDestroySurface_p = dlsym(dl_handle, "eglDestroySurface"); + eglGetConfigAttrib_p = dlsym(dl_handle, "eglGetConfigAttrib"); + eglGetCurrentContext_p = dlsym(dl_handle, "eglGetCurrentContext"); + eglGetError_p = dlsym(dl_handle, "eglGetError"); + eglGetPlatformDisplay_p = dlsym(dl_handle, "eglGetPlatformDisplay"); + eglInitialize_p = dlsym(dl_handle, "eglInitialize"); + eglMakeCurrent_p = dlsym(dl_handle, "eglMakeCurrent"); + eglSwapBuffers_p = dlsym(dl_handle, "eglSwapBuffers"); + eglReleaseThread_p = dlsym(dl_handle, "eglReleaseThread"); + eglSwapInterval_p = dlsym(dl_handle, "eglSwapInterval"); + eglTerminate_p = dlsym(dl_handle, "eglTerminate"); + eglGetCurrentSurface_p = dlsym(dl_handle,"eglGetCurrentSurface"); + break; + } } JNIEXPORT jboolean JNICALL Java_org_lwjgl_glfw_GLFW_nativeEglInit(JNIEnv* env, jclass clazz) { isInputReady = 1; - mainThreadID = pthread_mach_thread_np(pthread_self()); + mainThreadID = gettid(); - debug("EGLBridge: Initialized!"); - // printf("EGLBridge: ThreadID=%d\n", gettid()); - debug("EGLBridge: EGLDisplay=%p, EGLSurface=%p", + //const char *renderer = getenv("POJAV_RENDERER"); + //if (strncmp("opengles", renderer, 8) == 0) { + NSString *renderer = @(getenv("RENDERER")); + if ([renderer hasPrefix:@"libgl4es"] || [renderer hasPrefix:@"libtinygl4angle"]) { + config_renderer = RENDERER_MTL_ANGLE; + loadSymbols(); + if (potatoBridge.eglDisplay == EGL_NO_DISPLAY) { + potatoBridge.eglDisplay = eglGetPlatformDisplay_p(EGL_PLATFORM_ANGLE_ANGLE, (void *)EGL_DEFAULT_DISPLAY, NULL); + if (potatoBridge.eglDisplay == EGL_NO_DISPLAY) { + NSLog(@"EGLBridge: Error eglGetDefaultDisplay() failed: 0x%x", eglGetError_p()); + return JNI_FALSE; + } + } + + NSLog(@"EGLBridge: Initializing"); + // printf("EGLBridge: ANativeWindow pointer = %p\n", potatoBridge.androidWindow); + //(*env)->ThrowNew(env,(*env)->FindClass(env,"java/lang/Exception"),"Trace exception"); + if (!eglInitialize_p(potatoBridge.eglDisplay, NULL, NULL)) { + NSLog(@"EGLBridge: Error eglInitialize() failed: 0x%x", eglGetError_p()); + return JNI_FALSE; + } + + static const EGLint attribs[] = { + EGL_RED_SIZE, 8, + EGL_GREEN_SIZE, 8, + EGL_BLUE_SIZE, 8, + EGL_ALPHA_SIZE, 8, + // Minecraft required on initial 24 + EGL_DEPTH_SIZE, 24, + EGL_RENDERABLE_TYPE, EGL_OPENGL_ES3_BIT, + EGL_NONE + }; + + EGLint num_configs; + EGLint vid; + + if (!eglChooseConfig_p(potatoBridge.eglDisplay, attribs, &config, 1, &num_configs)) { + NSLog(@"EGLBridge: Error couldn't get an EGL visual config: 0x%x", eglGetError_p()); + return JNI_FALSE; + } + + assert(config); + assert(num_configs > 0); + + if (!eglGetConfigAttrib_p(potatoBridge.eglDisplay, config, EGL_NATIVE_VISUAL_ID, &vid)) { + NSLog(@"EGLBridge: Error eglGetConfigAttrib() failed: 0x%x", eglGetError_p()); + return JNI_FALSE; + } + + //ANativeWindow_setBuffersGeometry(potatoBridge.androidWindow, 0, 0, vid); + + if (!eglBindAPI_p(EGL_OPENGL_API)) { + NSLog(@"EGLBridge: Failed to bind EGL_OPENGL_API, fallbacking to EGL_OPENGL_ES_API, error=0x%x", eglGetError_p()); + eglBindAPI_p(EGL_OPENGL_ES_API); + } + + potatoBridge.eglSurface = eglCreateWindowSurface_p(potatoBridge.eglDisplay, config, (__bridge EGLNativeWindowType) ((SurfaceViewController *)viewController).surfaceView.layer, NULL); + NSLog(@"Layer %@", ((SurfaceViewController *)viewController).surfaceView.layer); + + if (!potatoBridge.eglSurface) { + NSLog(@"EGLBridge: Error eglCreateWindowSurface failed: 0x%x", eglGetError_p()); + //(*env)->ThrowNew(env,(*env)->FindClass(env,"java/lang/Exception"),"Trace exception"); + return JNI_FALSE; + } + + NSLog(@"EGLBridge: Initialized!"); + NSLog(@"EGLBridge: ThreadID=%d", gettid()); + NSLog(@"EGLBridge: EGLDisplay=%p, EGLSurface=%p", /* window==0 ? EGL_NO_CONTEXT : */ - potatoBridge.eglDisplay, - potatoBridge.eglSurface - ); + potatoBridge.eglDisplay, + potatoBridge.eglSurface + ); + return JNI_TRUE; + // } else if (strcmp(renderer, "vulkan_zink") == 0) { + } else if ([renderer hasPrefix:@"libOSMesa"]) { + config_renderer = RENDERER_VK_ZINK; + + setenv("GALLIUM_DRIVER","zink",1); + loadSymbols(); + if(OSMesaCreateContext_p == NULL) { + NSLog(@"OSMDroid: %s",dlerror()); + return JNI_FALSE; + } + + NSLog(@"OSMDroid: width=%i;height=%i, reserving %i bytes for frame buffer", savedWidth, savedHeight, + savedWidth * 4 * savedHeight); + gbuffer = malloc(savedWidth * 4 * savedHeight+1); + if (gbuffer) { + NSLog(@"OSMDroid: created frame buffer"); + return JNI_TRUE; + } else { + NSLog(@"OSMDroid: can't generate frame buffer"); + return JNI_FALSE; + } + } + + return JNI_FALSE; +} + +int32_t stride; +bool stopSwapBuffers; +void flipFrame() { + switch (config_renderer) { + case RENDERER_MTL_ANGLE: { + if (!eglSwapBuffers_p(potatoBridge.eglDisplay, potatoBridge.eglSurface)) { + if (eglGetError_p() == EGL_BAD_SURFACE) { + stopSwapBuffers = true; + closeGLFWWindow(); + } + } + } break; + + case RENDERER_VK_ZINK: { + glFinish_p(); + } break; + } +} +JNIEXPORT jboolean JNICALL Java_org_lwjgl_glfw_GLFW_nativeEglSwapBuffers(JNIEnv *env, jclass clazz) { + if (stopSwapBuffers) { + return JNI_FALSE; + } + flipFrame(); + return JNI_TRUE; } JNIEXPORT jboolean JNICALL Java_org_lwjgl_glfw_GLFW_nativeEglMakeCurrent(JNIEnv* env, jclass clazz, jlong window) { - mach_port_t tid = pthread_mach_thread_np(pthread_self()); - MGLContext *currCtx = MGLContext.currentContext; - MGLContext *localContext = [[NSThread currentThread] threadDictionary][@"gl_context"]; - EGLBoolean success; + //if(OSMesaGetCurrentContext_p() != NULL) { + // printf("OSMDroid: skipped context reset\n"); + // return JNI_TRUE; + //} + + switch (config_renderer) { + case RENDERER_MTL_ANGLE: { + EGLContext *currCtx = eglGetCurrentContext_p(); + NSLog(@"EGLBridge: Comparing: thr=%d, this=0x%llx, curr=%p", gettid(), window, currCtx); + if (currCtx == NULL || window == 0) { + /*if (window != 0x0 && potatoBridge.eglContextOld != NULL && potatoBridge.eglContextOld != (void *) window) { + // Create new pbuffer per thread + // TODO get window size for 2nd+ window! + int surfaceWidth, surfaceHeight; + eglQuerySurface(potatoBridge.eglDisplay, potatoBridge.eglSurface, EGL_WIDTH, &surfaceWidth); + eglQuerySurface(potatoBridge.eglDisplay, potatoBridge.eglSurface, EGL_HEIGHT, &surfaceHeight); + int surfaceAttr[] = { + EGL_WIDTH, surfaceWidth, + EGL_HEIGHT, surfaceHeight, + EGL_NONE + }; + potatoBridge.eglSurface = eglCreatePbufferSurface(potatoBridge.eglDisplay, config, surfaceAttr); + printf("EGLBridge: created pbuffer surface %p for context %p\n", potatoBridge.eglSurface, window); + }*/ + //potatoBridge.eglContextOld = (void *) window; + // eglMakeCurrent(potatoBridge.eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); + NSLog(@"EGLBridge: Making current on window 0x%llx on thread %d", window, gettid()); + EGLBoolean success = eglMakeCurrent_p( + potatoBridge.eglDisplay, + window==0 ? (EGLSurface *) 0 : potatoBridge.eglSurface, + window==0 ? (EGLSurface *) 0 : potatoBridge.eglSurface, + /* window==0 ? EGL_NO_CONTEXT : */ (EGLContext *) window + ); + if (success == EGL_FALSE) { + NSLog(@"EGLBridge: Error: eglMakeCurrent() failed: 0x%x", eglGetError_p()); + } else { + NSLog(@"EGLBridge: eglMakeCurrent() succeed!"); + } - debug("EGLBridge: Comparing: thr=%d, this=%p, curr=%p", (int)tid, (void *)window, currCtx); - debug("EGLBridge: Making current on window %p on thread (%d)", (void *)window, (int)tid); - [MGLContext setCurrentContext:nil]; - if (window != 0) { - if ((jlong)localContext != window) { - debug("EGLBridge ERROR: Context mismatch! local=%p, input=%p", localContext, (void *)window); - } - success = [MGLContext setCurrentContext:localContext forLayer:(MGLLayer *)viewController.view.subviews[0].layer] == YES; - } - - if (success == EGL_FALSE) { - debug("Error: eglMakeCurrent() failed: %x", eglGetError()); - } - - RegalMakeCurrent_func *RegalMakeCurrent = (RegalMakeCurrent_func *) dlsym(RTLD_DEFAULT, "RegalMakeCurrent"); - if (RegalMakeCurrent) { - RegalMakeCurrent(potatoBridge.eglContext); - } - - // Test + // Test #ifdef GLES_TEST - glClearColor(0.4f, 0.4f, 0.4f, 1.0f); - glClear(GL_COLOR_BUFFER_BIT); - eglSwapBuffers(potatoBridge.eglDisplay, potatoBridge.eglSurface); - debug("First frame error: %x", eglGetError()); + glClearColor(0.4f, 0.4f, 0.4f, 1.0f); + glClear(GL_COLOR_BUFFER_BIT); + eglSwapBuffers(potatoBridge.eglDisplay, potatoBridge.eglSurface); + NSLog(@"First frame error: 0x%x", eglGetError()); #endif - if (success == EGL_TRUE && GL4ES_HANDLE == NULL) { - GL4ES_HANDLE = dlopen(getenv("RENDERER"), RTLD_GLOBAL); - debug("%s=%p, error=%s", getenv("RENDERER"), GL4ES_HANDLE, dlerror()); + if (success == EGL_TRUE) { + void *gl4es_handle = dlopen(getenv("RENDERER"), RTLD_GLOBAL); + debug("%s=%p, error=%s", getenv("RENDERER"), gl4es_handle, dlerror()); - gl4esInitialize_func *gl4esInitialize = (gl4esInitialize_func*) dlsym(GL4ES_HANDLE, "initialize_gl4es"); - // debug("initialize_gl4es = %p", gl4esInitialize); - if (gl4esInitialize) { - gl4esInitialize(); - } else { - debug("%s", dlerror()); + gl4esInitialize_func *gl4esInitialize = (gl4esInitialize_func*) dlsym(gl4es_handle, "initialize_gl4es"); + // debug("initialize_gl4es = %p", gl4esInitialize); + if (gl4esInitialize) { + gl4esInitialize(); + } else { + debug("%s", dlerror()); + } + debug("Renderer init success"); + } + + // idk this should convert or just `return success;`... + return success == EGL_TRUE ? JNI_TRUE : JNI_FALSE; + } else { + // (*env)->ThrowNew(env,(*env)->FindClass(env,"java/lang/Exception"),"Trace exception"); + return JNI_FALSE; + } + } + + case RENDERER_VK_ZINK: { + NSLog(@"OSMDroid: making current"); + GLboolean result = OSMesaMakeCurrent_p((OSMesaContext)window,gbuffer,GL_UNSIGNED_BYTE,savedWidth,savedHeight); + //ANativeWindow_lock(potatoBridge.androidWindow,&buf,NULL); + OSMesaPixelStore_p(OSMESA_ROW_LENGTH, savedWidth); + //ANativeWindow_unlockAndPost(potatoBridge.androidWindow); + + OSMesaPixelStore_p(OSMESA_Y_UP,0); + NSLog(@"OSMDroid: vendor: %s",glGetString_p(GL_VENDOR)); + NSLog(@"OSMDroid: renderer: %s",glGetString_p(GL_RENDERER)); + glClear_p(GL_COLOR_BUFFER_BIT); + glClearColor_p(0.4f, 0.4f, 0.4f, 1.0f); + flipFrame(); + return result; } - debug("Renderer init success"); } - // idk this should convert or just `return success;`... - return success == EGL_TRUE ? JNI_TRUE : JNI_FALSE; + return JNI_FALSE; } -JNIEXPORT void JNICALL Java_org_lwjgl_glfw_GLFW_nativeEglDetachOnCurrentThread(JNIEnv *env, jclass clazz) { - [MGLContext setCurrentContext:nil]; -} - -JNIEXPORT jlong JNICALL Java_org_lwjgl_glfw_GLFW_nativeEglCreateContext(JNIEnv *env, jclass clazz, jlong contextSrc) { - MGLContext *localContext; - mach_port_t tid = pthread_mach_thread_np(pthread_self()); - if (tid != mainThreadID) { - localContext = [[MGLContext alloc] initWithAPI:kMGLRenderingAPIOpenGLES3 sharegroup:sharegroup]; - debug("EGLBridge: Created CTX pointer=%p, shareCTX=%p, thread=%d", localContext, (void *)contextSrc, (int)tid); - } else { - localContext = firstContext; - debug("EGLBridge: Using CTX pointer=%p, shareCTX=%p, thread=%d", localContext, (void *)contextSrc, (int)tid); +JNIEXPORT void JNICALL +Java_org_lwjgl_glfw_GLFW_nativeEglDetachOnCurrentThread(JNIEnv *env, jclass clazz) { + //Obstruct the context on the current thread + + switch (config_renderer) { + case RENDERER_MTL_ANGLE: { + eglMakeCurrent_p(potatoBridge.eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); + } break; + + case RENDERER_VK_ZINK: { + // Nothing to do here + } break; } - [[NSThread currentThread] threadDictionary][@"gl_context"] = localContext; - return (jlong)localContext; +} + +JNIEXPORT jlong JNICALL +Java_org_lwjgl_glfw_GLFW_nativeEglCreateContext(JNIEnv *env, jclass clazz, jlong contextSrc) { + switch (config_renderer) { + case RENDERER_MTL_ANGLE: { + const EGLint ctx_attribs[] = { + EGL_CONTEXT_CLIENT_VERSION, 3, + EGL_NONE + }; + EGLContext* ctx = eglCreateContext_p(potatoBridge.eglDisplay, config, (void*)contextSrc, ctx_attribs); + + potatoBridge.eglContext = ctx; + + NSLog(@"EGLBridge: Created CTX pointer = %p",ctx); + //(*env)->ThrowNew(env,(*env)->FindClass(env,"java/lang/Exception"),"Trace exception"); + return (long)ctx; + } + + case RENDERER_VK_ZINK: { + NSLog(@"OSMDroid: generating context"); + void* ctx = OSMesaCreateContext_p(OSMESA_RGBA, (OSMesaContext)contextSrc); + NSLog(@"OSMDroid: context=%p",ctx); + return (jlong)ctx; + } + } + + return 0l; } JNIEXPORT jboolean JNICALL Java_org_lwjgl_glfw_GLFW_nativeEglTerminate(JNIEnv* env, jclass clazz) { @@ -164,26 +454,38 @@ JNIEXPORT jboolean JNICALL Java_org_lwjgl_glfw_GLFW_nativeEglTerminate(JNIEnv* e } JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_nativeRegalMakeCurrent(JNIEnv *env, jclass clazz) { - debug("Regal: making current"); + //NSLog(@"Regal: making current"); - RegalMakeCurrent_func *RegalMakeCurrent = (RegalMakeCurrent_func *) dlsym(RTLD_DEFAULT, "RegalMakeCurrent"); - assert(RegalMakeCurrent); - RegalMakeCurrent(potatoBridge.eglContext); + //RegalMakeCurrent_func *RegalMakeCurrent = (RegalMakeCurrent_func *) dlsym(RTLD_DEFAULT, "RegalMakeCurrent"); + //assert(RegalMakeCurrent); + //RegalMakeCurrent(potatoBridge.eglContext); + + NSLog(@"Regal removed"); + abort(); } -bool stopMakeCurrent; -JNIEXPORT jboolean JNICALL Java_org_lwjgl_glfw_GLFW_nativeEglSwapBuffers(JNIEnv *env, jclass clazz) { - jboolean result = (jboolean) eglSwapBuffers(potatoBridge.eglDisplay, eglGetCurrentSurface(EGL_DRAW)); - - if (!result) { - mach_port_t tid = pthread_mach_thread_np(pthread_self()); - EGLint error = eglGetError(); - debug("eglSwapBuffers error=%x, thread=%d isMainThread=%d", error, (int)tid, mainThreadID == tid); +JNIEXPORT jlong JNICALL +Java_org_lwjgl_opengl_GL_getGraphicsBufferAddr(JNIEnv *env, jobject thiz) { + return (jlong)&gbuffer; +} +JNIEXPORT jintArray JNICALL +Java_org_lwjgl_opengl_GL_getNativeWidthHeight(JNIEnv *env, jobject thiz) { + jintArray ret = (*env)->NewIntArray(env,2); + jint arr[] = {savedWidth, savedHeight}; + (*env)->SetIntArrayRegion(env,ret,0,2,arr); + return ret; +} +JNIEXPORT jboolean JNICALL Java_org_lwjgl_glfw_GLFW_nativeEglSwapInterval(JNIEnv *env, jclass clazz, jint interval) { + switch (config_renderer) { + case RENDERER_MTL_ANGLE: { + return eglSwapInterval_p(potatoBridge.eglDisplay, interval); + } break; + + case RENDERER_VK_ZINK: { + NSLog(@"eglSwapInterval: NOT IMPLEMENTED YET!"); + // Nothing to do here + } break; } - return result; -} - -JNIEXPORT jboolean JNICALL Java_org_lwjgl_glfw_GLFW_nativeEglSwapInterval(JNIEnv *env, jclass clazz, jint interval) { - return eglSwapInterval(potatoBridge.eglDisplay, interval); + return JNI_FALSE; } diff --git a/Natives/osmesa_internal.h b/Natives/osmesa_internal.h new file mode 100644 index 00000000..9ef8bea8 --- /dev/null +++ b/Natives/osmesa_internal.h @@ -0,0 +1,476 @@ +#include + +#include + +struct pipe_screen; + +//only get what we need to access/modify +enum st_attachment_type { + ST_ATTACHMENT_FRONT_LEFT, + ST_ATTACHMENT_BACK_LEFT, + ST_ATTACHMENT_FRONT_RIGHT, + ST_ATTACHMENT_BACK_RIGHT, + ST_ATTACHMENT_DEPTH_STENCIL, + ST_ATTACHMENT_ACCUM, + ST_ATTACHMENT_SAMPLE, + + ST_ATTACHMENT_COUNT, + ST_ATTACHMENT_INVALID = -1 +}; +enum pipe_format { + PIPE_FORMAT_NONE, + PIPE_FORMAT_B8G8R8A8_UNORM, + PIPE_FORMAT_B8G8R8X8_UNORM, + PIPE_FORMAT_A8R8G8B8_UNORM, + PIPE_FORMAT_X8R8G8B8_UNORM, + PIPE_FORMAT_B5G5R5A1_UNORM, + PIPE_FORMAT_R4G4B4A4_UNORM, + PIPE_FORMAT_B4G4R4A4_UNORM, + PIPE_FORMAT_R5G6B5_UNORM, + PIPE_FORMAT_B5G6R5_UNORM, + PIPE_FORMAT_R10G10B10A2_UNORM, + PIPE_FORMAT_L8_UNORM, /**< ubyte luminance */ + PIPE_FORMAT_A8_UNORM, /**< ubyte alpha */ + PIPE_FORMAT_I8_UNORM, /**< ubyte intensity */ + PIPE_FORMAT_L8A8_UNORM, /**< ubyte alpha, luminance */ + PIPE_FORMAT_L16_UNORM, /**< ushort luminance */ + PIPE_FORMAT_UYVY, + PIPE_FORMAT_YUYV, + PIPE_FORMAT_Z16_UNORM, + PIPE_FORMAT_Z16_UNORM_S8_UINT, + PIPE_FORMAT_Z32_UNORM, + PIPE_FORMAT_Z32_FLOAT, + PIPE_FORMAT_Z24_UNORM_S8_UINT, + PIPE_FORMAT_S8_UINT_Z24_UNORM, + PIPE_FORMAT_Z24X8_UNORM, + PIPE_FORMAT_X8Z24_UNORM, + PIPE_FORMAT_S8_UINT, /**< ubyte stencil */ + PIPE_FORMAT_R64_FLOAT, + PIPE_FORMAT_R64G64_FLOAT, + PIPE_FORMAT_R64G64B64_FLOAT, + PIPE_FORMAT_R64G64B64A64_FLOAT, + PIPE_FORMAT_R32_FLOAT, + PIPE_FORMAT_R32G32_FLOAT, + PIPE_FORMAT_R32G32B32_FLOAT, + PIPE_FORMAT_R32G32B32A32_FLOAT, + PIPE_FORMAT_R32_UNORM, + PIPE_FORMAT_R32G32_UNORM, + PIPE_FORMAT_R32G32B32_UNORM, + PIPE_FORMAT_R32G32B32A32_UNORM, + PIPE_FORMAT_R32_USCALED, + PIPE_FORMAT_R32G32_USCALED, + PIPE_FORMAT_R32G32B32_USCALED, + PIPE_FORMAT_R32G32B32A32_USCALED, + PIPE_FORMAT_R32_SNORM, + PIPE_FORMAT_R32G32_SNORM, + PIPE_FORMAT_R32G32B32_SNORM, + PIPE_FORMAT_R32G32B32A32_SNORM, + PIPE_FORMAT_R32_SSCALED, + PIPE_FORMAT_R32G32_SSCALED, + PIPE_FORMAT_R32G32B32_SSCALED, + PIPE_FORMAT_R32G32B32A32_SSCALED, + PIPE_FORMAT_R16_UNORM, + PIPE_FORMAT_R16G16_UNORM, + PIPE_FORMAT_R16G16B16_UNORM, + PIPE_FORMAT_R16G16B16A16_UNORM, + PIPE_FORMAT_R16_USCALED, + PIPE_FORMAT_R16G16_USCALED, + PIPE_FORMAT_R16G16B16_USCALED, + PIPE_FORMAT_R16G16B16A16_USCALED, + PIPE_FORMAT_R16_SNORM, + PIPE_FORMAT_R16G16_SNORM, + PIPE_FORMAT_R16G16B16_SNORM, + PIPE_FORMAT_R16G16B16A16_SNORM, + PIPE_FORMAT_R16_SSCALED, + PIPE_FORMAT_R16G16_SSCALED, + PIPE_FORMAT_R16G16B16_SSCALED, + PIPE_FORMAT_R16G16B16A16_SSCALED, + PIPE_FORMAT_R8_UNORM, + PIPE_FORMAT_R8G8_UNORM, + PIPE_FORMAT_R8G8B8_UNORM, + PIPE_FORMAT_B8G8R8_UNORM, + PIPE_FORMAT_R8G8B8A8_UNORM, + PIPE_FORMAT_X8B8G8R8_UNORM, + PIPE_FORMAT_R8_USCALED, + PIPE_FORMAT_R8G8_USCALED, + PIPE_FORMAT_R8G8B8_USCALED, + PIPE_FORMAT_B8G8R8_USCALED, + PIPE_FORMAT_R8G8B8A8_USCALED, + PIPE_FORMAT_B8G8R8A8_USCALED, + PIPE_FORMAT_A8B8G8R8_USCALED, + PIPE_FORMAT_R8_SNORM, + PIPE_FORMAT_R8G8_SNORM, + PIPE_FORMAT_R8G8B8_SNORM, + PIPE_FORMAT_B8G8R8_SNORM, + PIPE_FORMAT_R8G8B8A8_SNORM, + PIPE_FORMAT_B8G8R8A8_SNORM, + PIPE_FORMAT_R8_SSCALED, + PIPE_FORMAT_R8G8_SSCALED, + PIPE_FORMAT_R8G8B8_SSCALED, + PIPE_FORMAT_B8G8R8_SSCALED, + PIPE_FORMAT_R8G8B8A8_SSCALED, + PIPE_FORMAT_B8G8R8A8_SSCALED, + PIPE_FORMAT_A8B8G8R8_SSCALED, + PIPE_FORMAT_R32_FIXED, + PIPE_FORMAT_R32G32_FIXED, + PIPE_FORMAT_R32G32B32_FIXED, + PIPE_FORMAT_R32G32B32A32_FIXED, + PIPE_FORMAT_R16_FLOAT, + PIPE_FORMAT_R16G16_FLOAT, + PIPE_FORMAT_R16G16B16_FLOAT, + PIPE_FORMAT_R16G16B16A16_FLOAT, + + /* sRGB formats */ + PIPE_FORMAT_L8_SRGB, + PIPE_FORMAT_R8_SRGB, + PIPE_FORMAT_L8A8_SRGB, + PIPE_FORMAT_R8G8_SRGB, + PIPE_FORMAT_R8G8B8_SRGB, + PIPE_FORMAT_B8G8R8_SRGB, + PIPE_FORMAT_A8B8G8R8_SRGB, + PIPE_FORMAT_X8B8G8R8_SRGB, + PIPE_FORMAT_B8G8R8A8_SRGB, + PIPE_FORMAT_B8G8R8X8_SRGB, + PIPE_FORMAT_A8R8G8B8_SRGB, + PIPE_FORMAT_X8R8G8B8_SRGB, + PIPE_FORMAT_R8G8B8A8_SRGB, + + /* compressed formats */ + PIPE_FORMAT_DXT1_RGB, + PIPE_FORMAT_DXT1_RGBA, + PIPE_FORMAT_DXT3_RGBA, + PIPE_FORMAT_DXT5_RGBA, + + /* sRGB, compressed */ + PIPE_FORMAT_DXT1_SRGB, + PIPE_FORMAT_DXT1_SRGBA, + PIPE_FORMAT_DXT3_SRGBA, + PIPE_FORMAT_DXT5_SRGBA, + + /* rgtc compressed */ + PIPE_FORMAT_RGTC1_UNORM, + PIPE_FORMAT_RGTC1_SNORM, + PIPE_FORMAT_RGTC2_UNORM, + PIPE_FORMAT_RGTC2_SNORM, + + PIPE_FORMAT_R8G8_B8G8_UNORM, + PIPE_FORMAT_G8R8_G8B8_UNORM, + + /* mixed formats */ + PIPE_FORMAT_R8SG8SB8UX8U_NORM, + PIPE_FORMAT_R5SG5SB6U_NORM, + + /* TODO: re-order these */ + PIPE_FORMAT_A8B8G8R8_UNORM, + PIPE_FORMAT_B5G5R5X1_UNORM, + PIPE_FORMAT_R10G10B10A2_USCALED, + PIPE_FORMAT_R11G11B10_FLOAT, + PIPE_FORMAT_R9G9B9E5_FLOAT, + PIPE_FORMAT_Z32_FLOAT_S8X24_UINT, + PIPE_FORMAT_R1_UNORM, + PIPE_FORMAT_R10G10B10X2_USCALED, + PIPE_FORMAT_R10G10B10X2_SNORM, + PIPE_FORMAT_L4A4_UNORM, + PIPE_FORMAT_A2R10G10B10_UNORM, + PIPE_FORMAT_A2B10G10R10_UNORM, + PIPE_FORMAT_B10G10R10A2_UNORM, + PIPE_FORMAT_R10SG10SB10SA2U_NORM, + PIPE_FORMAT_R8G8Bx_SNORM, + PIPE_FORMAT_R8G8B8X8_UNORM, + PIPE_FORMAT_B4G4R4X4_UNORM, + + /* some stencil samplers formats */ + PIPE_FORMAT_X24S8_UINT, + PIPE_FORMAT_S8X24_UINT, + PIPE_FORMAT_X32_S8X24_UINT, + + PIPE_FORMAT_R3G3B2_UNORM, + PIPE_FORMAT_B2G3R3_UNORM, + PIPE_FORMAT_L16A16_UNORM, + PIPE_FORMAT_A16_UNORM, + PIPE_FORMAT_I16_UNORM, + + PIPE_FORMAT_LATC1_UNORM, + PIPE_FORMAT_LATC1_SNORM, + PIPE_FORMAT_LATC2_UNORM, + PIPE_FORMAT_LATC2_SNORM, + + PIPE_FORMAT_A8_SNORM, + PIPE_FORMAT_L8_SNORM, + PIPE_FORMAT_L8A8_SNORM, + PIPE_FORMAT_I8_SNORM, + PIPE_FORMAT_A16_SNORM, + PIPE_FORMAT_L16_SNORM, + PIPE_FORMAT_L16A16_SNORM, + PIPE_FORMAT_I16_SNORM, + + PIPE_FORMAT_A16_FLOAT, + PIPE_FORMAT_L16_FLOAT, + PIPE_FORMAT_L16A16_FLOAT, + PIPE_FORMAT_I16_FLOAT, + PIPE_FORMAT_A32_FLOAT, + PIPE_FORMAT_L32_FLOAT, + PIPE_FORMAT_L32A32_FLOAT, + PIPE_FORMAT_I32_FLOAT, + + PIPE_FORMAT_YV12, + PIPE_FORMAT_YV16, + PIPE_FORMAT_IYUV, /**< aka I420 */ + PIPE_FORMAT_NV12, + PIPE_FORMAT_NV21, + + /* PIPE_FORMAT_Y8_U8_V8_420_UNORM = IYUV */ + /* PIPE_FORMAT_Y8_U8V8_420_UNORM = NV12 */ + PIPE_FORMAT_Y8_U8_V8_422_UNORM, + PIPE_FORMAT_Y8_U8V8_422_UNORM, + PIPE_FORMAT_Y8_U8_V8_444_UNORM, + + PIPE_FORMAT_Y16_U16_V16_420_UNORM, + /* PIPE_FORMAT_Y16_U16V16_420_UNORM */ + PIPE_FORMAT_Y16_U16_V16_422_UNORM, + PIPE_FORMAT_Y16_U16V16_422_UNORM, + PIPE_FORMAT_Y16_U16_V16_444_UNORM, + + PIPE_FORMAT_A4R4_UNORM, + PIPE_FORMAT_R4A4_UNORM, + PIPE_FORMAT_R8A8_UNORM, + PIPE_FORMAT_A8R8_UNORM, + + PIPE_FORMAT_R10G10B10A2_SSCALED, + PIPE_FORMAT_R10G10B10A2_SNORM, + + PIPE_FORMAT_B10G10R10A2_USCALED, + PIPE_FORMAT_B10G10R10A2_SSCALED, + PIPE_FORMAT_B10G10R10A2_SNORM, + + PIPE_FORMAT_R8_UINT, + PIPE_FORMAT_R8G8_UINT, + PIPE_FORMAT_R8G8B8_UINT, + PIPE_FORMAT_R8G8B8A8_UINT, + + PIPE_FORMAT_R8_SINT, + PIPE_FORMAT_R8G8_SINT, + PIPE_FORMAT_R8G8B8_SINT, + PIPE_FORMAT_R8G8B8A8_SINT, + + PIPE_FORMAT_R16_UINT, + PIPE_FORMAT_R16G16_UINT, + PIPE_FORMAT_R16G16B16_UINT, + PIPE_FORMAT_R16G16B16A16_UINT, + + PIPE_FORMAT_R16_SINT, + PIPE_FORMAT_R16G16_SINT, + PIPE_FORMAT_R16G16B16_SINT, + PIPE_FORMAT_R16G16B16A16_SINT, + + PIPE_FORMAT_R32_UINT, + PIPE_FORMAT_R32G32_UINT, + PIPE_FORMAT_R32G32B32_UINT, + PIPE_FORMAT_R32G32B32A32_UINT, + + PIPE_FORMAT_R32_SINT, + PIPE_FORMAT_R32G32_SINT, + PIPE_FORMAT_R32G32B32_SINT, + PIPE_FORMAT_R32G32B32A32_SINT, + + PIPE_FORMAT_R64_UINT, + PIPE_FORMAT_R64_SINT, + + PIPE_FORMAT_A8_UINT, + PIPE_FORMAT_I8_UINT, + PIPE_FORMAT_L8_UINT, + PIPE_FORMAT_L8A8_UINT, + + PIPE_FORMAT_A8_SINT, + PIPE_FORMAT_I8_SINT, + PIPE_FORMAT_L8_SINT, + PIPE_FORMAT_L8A8_SINT, + + PIPE_FORMAT_A16_UINT, + PIPE_FORMAT_I16_UINT, + PIPE_FORMAT_L16_UINT, + PIPE_FORMAT_L16A16_UINT, + + PIPE_FORMAT_A16_SINT, + PIPE_FORMAT_I16_SINT, + PIPE_FORMAT_L16_SINT, + PIPE_FORMAT_L16A16_SINT, + + PIPE_FORMAT_A32_UINT, + PIPE_FORMAT_I32_UINT, + PIPE_FORMAT_L32_UINT, + PIPE_FORMAT_L32A32_UINT, + + PIPE_FORMAT_A32_SINT, + PIPE_FORMAT_I32_SINT, + PIPE_FORMAT_L32_SINT, + PIPE_FORMAT_L32A32_SINT, + + PIPE_FORMAT_B8G8R8_UINT, + PIPE_FORMAT_B8G8R8A8_UINT, + + PIPE_FORMAT_B8G8R8_SINT, + PIPE_FORMAT_B8G8R8A8_SINT, + + PIPE_FORMAT_A8R8G8B8_UINT, + PIPE_FORMAT_A8B8G8R8_UINT, + PIPE_FORMAT_A2R10G10B10_UINT, + PIPE_FORMAT_A2B10G10R10_UINT, + PIPE_FORMAT_B10G10R10A2_UINT, + PIPE_FORMAT_B10G10R10A2_SINT, + PIPE_FORMAT_R5G6B5_UINT, + PIPE_FORMAT_B5G6R5_UINT, + PIPE_FORMAT_R5G5B5A1_UINT, + PIPE_FORMAT_B5G5R5A1_UINT, + PIPE_FORMAT_A1R5G5B5_UINT, + PIPE_FORMAT_A1B5G5R5_UINT, + PIPE_FORMAT_R4G4B4A4_UINT, + PIPE_FORMAT_B4G4R4A4_UINT, + PIPE_FORMAT_A4R4G4B4_UINT, + PIPE_FORMAT_A4B4G4R4_UINT, + PIPE_FORMAT_R3G3B2_UINT, + PIPE_FORMAT_B2G3R3_UINT, + + PIPE_FORMAT_ETC1_RGB8, + + PIPE_FORMAT_R8G8_R8B8_UNORM, + PIPE_FORMAT_G8R8_B8R8_UNORM, + + PIPE_FORMAT_R8G8B8X8_SNORM, + PIPE_FORMAT_R8G8B8X8_SRGB, + PIPE_FORMAT_R8G8B8X8_UINT, + PIPE_FORMAT_R8G8B8X8_SINT, + PIPE_FORMAT_B10G10R10X2_UNORM, + PIPE_FORMAT_R16G16B16X16_UNORM, + PIPE_FORMAT_R16G16B16X16_SNORM, + PIPE_FORMAT_R16G16B16X16_FLOAT, + PIPE_FORMAT_R16G16B16X16_UINT, + PIPE_FORMAT_R16G16B16X16_SINT, + PIPE_FORMAT_R32G32B32X32_FLOAT, + PIPE_FORMAT_R32G32B32X32_UINT, + PIPE_FORMAT_R32G32B32X32_SINT, + + PIPE_FORMAT_R8A8_SNORM, + PIPE_FORMAT_R16A16_UNORM, + PIPE_FORMAT_R16A16_SNORM, + PIPE_FORMAT_R16A16_FLOAT, + PIPE_FORMAT_R32A32_FLOAT, + PIPE_FORMAT_R8A8_UINT, + PIPE_FORMAT_R8A8_SINT, + PIPE_FORMAT_R16A16_UINT, + PIPE_FORMAT_R16A16_SINT, + PIPE_FORMAT_R32A32_UINT, + PIPE_FORMAT_R32A32_SINT, + PIPE_FORMAT_R10G10B10A2_UINT, + PIPE_FORMAT_R10G10B10A2_SINT, + + PIPE_FORMAT_B5G6R5_SRGB, + + PIPE_FORMAT_BPTC_RGBA_UNORM, + PIPE_FORMAT_BPTC_SRGBA, + PIPE_FORMAT_BPTC_RGB_FLOAT, + PIPE_FORMAT_BPTC_RGB_UFLOAT, + + PIPE_FORMAT_G8R8_UNORM, + PIPE_FORMAT_G8R8_SNORM, + PIPE_FORMAT_G16R16_UNORM, + PIPE_FORMAT_G16R16_SNORM, + + PIPE_FORMAT_A8B8G8R8_SNORM, + PIPE_FORMAT_X8B8G8R8_SNORM, + + PIPE_FORMAT_ETC2_RGB8, + PIPE_FORMAT_ETC2_SRGB8, + PIPE_FORMAT_ETC2_RGB8A1, + PIPE_FORMAT_ETC2_SRGB8A1, + PIPE_FORMAT_ETC2_RGBA8, + PIPE_FORMAT_ETC2_SRGBA8, + PIPE_FORMAT_ETC2_R11_UNORM, + PIPE_FORMAT_ETC2_R11_SNORM, + PIPE_FORMAT_ETC2_RG11_UNORM, + PIPE_FORMAT_ETC2_RG11_SNORM, + + PIPE_FORMAT_ASTC_4x4, + PIPE_FORMAT_ASTC_5x4, + PIPE_FORMAT_ASTC_5x5, + PIPE_FORMAT_ASTC_6x5, + PIPE_FORMAT_ASTC_6x6, + PIPE_FORMAT_ASTC_8x5, + PIPE_FORMAT_ASTC_8x6, + PIPE_FORMAT_ASTC_8x8, + PIPE_FORMAT_ASTC_10x5, + PIPE_FORMAT_ASTC_10x6, + PIPE_FORMAT_ASTC_10x8, + PIPE_FORMAT_ASTC_10x10, + PIPE_FORMAT_ASTC_12x10, + PIPE_FORMAT_ASTC_12x12, + + PIPE_FORMAT_ASTC_4x4_SRGB, + PIPE_FORMAT_ASTC_5x4_SRGB, + PIPE_FORMAT_ASTC_5x5_SRGB, + PIPE_FORMAT_ASTC_6x5_SRGB, + PIPE_FORMAT_ASTC_6x6_SRGB, + PIPE_FORMAT_ASTC_8x5_SRGB, + PIPE_FORMAT_ASTC_8x6_SRGB, + PIPE_FORMAT_ASTC_8x8_SRGB, + PIPE_FORMAT_ASTC_10x5_SRGB, + PIPE_FORMAT_ASTC_10x6_SRGB, + PIPE_FORMAT_ASTC_10x8_SRGB, + PIPE_FORMAT_ASTC_10x10_SRGB, + PIPE_FORMAT_ASTC_12x10_SRGB, + PIPE_FORMAT_ASTC_12x12_SRGB, + + PIPE_FORMAT_ASTC_3x3x3, + PIPE_FORMAT_ASTC_4x3x3, + PIPE_FORMAT_ASTC_4x4x3, + PIPE_FORMAT_ASTC_4x4x4, + PIPE_FORMAT_ASTC_5x4x4, + PIPE_FORMAT_ASTC_5x5x4, + PIPE_FORMAT_ASTC_5x5x5, + PIPE_FORMAT_ASTC_6x5x5, + PIPE_FORMAT_ASTC_6x6x5, + PIPE_FORMAT_ASTC_6x6x6, + + PIPE_FORMAT_ASTC_3x3x3_SRGB, + PIPE_FORMAT_ASTC_4x3x3_SRGB, + PIPE_FORMAT_ASTC_4x4x3_SRGB, + PIPE_FORMAT_ASTC_4x4x4_SRGB, + PIPE_FORMAT_ASTC_5x4x4_SRGB, + PIPE_FORMAT_ASTC_5x5x4_SRGB, + PIPE_FORMAT_ASTC_5x5x5_SRGB, + PIPE_FORMAT_ASTC_6x5x5_SRGB, + PIPE_FORMAT_ASTC_6x6x5_SRGB, + PIPE_FORMAT_ASTC_6x6x6_SRGB, + + PIPE_FORMAT_FXT1_RGB, + PIPE_FORMAT_FXT1_RGBA, + + PIPE_FORMAT_P010, + PIPE_FORMAT_P012, + PIPE_FORMAT_P016, + + PIPE_FORMAT_R10G10B10X2_UNORM, + PIPE_FORMAT_A1R5G5B5_UNORM, + PIPE_FORMAT_A1B5G5R5_UNORM, + PIPE_FORMAT_X1B5G5R5_UNORM, + PIPE_FORMAT_R5G5B5A1_UNORM, + PIPE_FORMAT_A4R4G4B4_UNORM, + PIPE_FORMAT_A4B4G4R4_UNORM, + + PIPE_FORMAT_G8R8_SINT, + PIPE_FORMAT_A8B8G8R8_SINT, + PIPE_FORMAT_X8B8G8R8_SINT, + + PIPE_FORMAT_ATC_RGB, + PIPE_FORMAT_ATC_RGBA_EXPLICIT, + PIPE_FORMAT_ATC_RGBA_INTERPOLATED, + + PIPE_FORMAT_Z24_UNORM_S8_UINT_AS_R8G8B8A8, + + PIPE_FORMAT_AYUV, + PIPE_FORMAT_XYUV, + + PIPE_FORMAT_R8_G8B8_420_UNORM, + + PIPE_FORMAT_COUNT +}; diff --git a/Natives/utils.h b/Natives/utils.h index cb3133f5..f9fa059b 100644 --- a/Natives/utils.h +++ b/Natives/utils.h @@ -36,10 +36,7 @@ static float resolutionScale = 1.0; UIViewController *viewController; -MGLContext *firstContext; -MGLSharegroup* sharegroup; - -void* GL4ES_HANDLE; +void* gbuffer; // OSMesa framebuffer JavaVM* runtimeJavaVMPtr; JNIEnv* runtimeJNIEnvPtr_ANDROID; @@ -56,6 +53,8 @@ jboolean isGrabbing; int savedWidth, savedHeight; +void _CGDataProviderReleaseBytePointerCallback(void *info,const void *pointer); + jboolean attachThread(bool isAndroid, JNIEnv** secondJNIEnvPtr); char** convert_to_char_array(JNIEnv *env, jobjectArray jstringArray); jobjectArray convert_from_char_array(JNIEnv *env, char **charArray, int num_rows); diff --git a/Natives/utils.m b/Natives/utils.m index 42cf378f..542d519e 100644 --- a/Natives/utils.m +++ b/Natives/utils.m @@ -8,7 +8,8 @@ #include "utils.h" -long shared_awt_surface; +void _CGDataProviderReleaseBytePointerCallback(void *info,const void *pointer) { +} char** convert_to_char_array(JNIEnv *env, jobjectArray jstringArray) { int num_rows = (*env)->GetArrayLength(env, jstringArray); @@ -57,14 +58,6 @@ jstring convertStringJVM(JNIEnv* srcEnv, JNIEnv* dstEnv, jstring srcStr) { return dstStr; } -JNIEXPORT void JNICALL Java_net_kdt_pojavlaunch_utils_JREUtils_setupBridgeSurfaceAWT(JNIEnv *env, jclass clazz, jlong surface) { - shared_awt_surface = surface; -} - -JNIEXPORT jlong JNICALL Java_android_view_Surface_nativeGetBridgeSurfaceAWT(JNIEnv *env, jclass clazz) { - return (jlong) shared_awt_surface; -} - JNIEXPORT jint JNICALL Java_android_os_OpenJDKNativeRegister_nativeRegisterNatives(JNIEnv *env, jclass clazz, jstring registerSymbol) { const char *register_symbol_c = (*env)->GetStringUTFChars(env, registerSymbol, 0); void *symbol = dlsym(RTLD_DEFAULT, register_symbol_c);