diff --git a/app_pojavlauncher/src/main/assets/components/lwjgl3/lwjgl-glfw-classes.jar b/app_pojavlauncher/src/main/assets/components/lwjgl3/lwjgl-glfw-classes.jar index d7a05d5e4..1696dd391 100644 Binary files a/app_pojavlauncher/src/main/assets/components/lwjgl3/lwjgl-glfw-classes.jar and b/app_pojavlauncher/src/main/assets/components/lwjgl3/lwjgl-glfw-classes.jar differ diff --git a/app_pojavlauncher/src/main/assets/components/lwjgl3/version b/app_pojavlauncher/src/main/assets/components/lwjgl3/version index c3b857f25..8ca3a4549 100644 --- a/app_pojavlauncher/src/main/assets/components/lwjgl3/version +++ b/app_pojavlauncher/src/main/assets/components/lwjgl3/version @@ -1 +1 @@ -1720909595576 \ No newline at end of file +1731408235037 \ No newline at end of file diff --git a/app_pojavlauncher/src/main/java/net/kdt/pojavlaunch/MainActivity.java b/app_pojavlauncher/src/main/java/net/kdt/pojavlaunch/MainActivity.java index 98aa1cc07..e4e034d06 100644 --- a/app_pojavlauncher/src/main/java/net/kdt/pojavlaunch/MainActivity.java +++ b/app_pojavlauncher/src/main/java/net/kdt/pojavlaunch/MainActivity.java @@ -240,8 +240,12 @@ public class MainActivity extends BaseActivity implements ControlButtonMenuListe @Override public void onAttachedToWindow() { - LauncherPreferences.computeNotchSize(this); - loadControls(); + // Post to get the correct display dimensions after layout. + mControlLayout.post(()->{ + LauncherPreferences.computeNotchSize(this); + Tools.getDisplayMetrics(this); + loadControls(); + }); } /** Boilerplate binding */ @@ -299,9 +303,16 @@ public class MainActivity extends BaseActivity implements ControlButtonMenuListe super.onConfigurationChanged(newConfig); if(mGyroControl != null) mGyroControl.updateOrientation(); - Tools.updateWindowSize(this); - minecraftGLView.refreshSize(); - runOnUiThread(() -> mControlLayout.refreshControlButtonPositions()); + // Layout resize is practically guaranteed on a configuration change, and `onConfigurationChanged` + // does not implicitly start a layout. So, request a layout and expect the screen dimensions to be valid after the] + // post. + mControlLayout.requestLayout(); + mControlLayout.post(()->{ + // Child of mControlLayout, so refreshing size here is correct + minecraftGLView.refreshSize(); + Tools.updateWindowSize(this); + mControlLayout.refreshControlButtonPositions(); + }); } @Override diff --git a/app_pojavlauncher/src/main/java/net/kdt/pojavlaunch/MinecraftGLSurface.java b/app_pojavlauncher/src/main/java/net/kdt/pojavlaunch/MinecraftGLSurface.java index 2c460558f..d29d54023 100644 --- a/app_pojavlauncher/src/main/java/net/kdt/pojavlaunch/MinecraftGLSurface.java +++ b/app_pojavlauncher/src/main/java/net/kdt/pojavlaunch/MinecraftGLSurface.java @@ -326,14 +326,22 @@ public class MinecraftGLSurface extends View implements GrabListener { return true; } - - - - /** Called when the size need to be set at any point during the surface lifecycle **/ public void refreshSize(){ - windowWidth = Tools.getDisplayFriendlyRes(Tools.currentDisplayMetrics.widthPixels, mScaleFactor); - windowHeight = Tools.getDisplayFriendlyRes(Tools.currentDisplayMetrics.heightPixels, mScaleFactor); + refreshSize(false); + } + + /** Same as refreshSize, but allows you to force an immediate size update **/ + public void refreshSize(boolean immediate) { + if(isInLayout() && !immediate) { + post(this::refreshSize); + return; + } + // Use the width and height of the View instead of display dimensions to avoid + // getting squiched/stretched due to inconsistencies between the layout and + // screen dimensions. + windowWidth = Tools.getDisplayFriendlyRes(getWidth(), mScaleFactor); + windowHeight = Tools.getDisplayFriendlyRes(getHeight(), mScaleFactor); if(mSurface == null){ Log.w("MGLSurface", "Attempt to refresh size on null surface"); return; @@ -355,8 +363,9 @@ public class MinecraftGLSurface extends View implements GrabListener { } private void realStart(Surface surface){ - // Initial size set - refreshSize(); + // Initial size set. Request immedate refresh, otherwise the initial width and height for the game + // may be broken/unknown. + refreshSize(true); //Load Minecraft options: MCOptionUtils.set("fullscreen", "off"); diff --git a/app_pojavlauncher/src/main/java/net/kdt/pojavlaunch/Tools.java b/app_pojavlauncher/src/main/java/net/kdt/pojavlaunch/Tools.java index 0268bce8c..5022c8800 100644 --- a/app_pojavlauncher/src/main/java/net/kdt/pojavlaunch/Tools.java +++ b/app_pojavlauncher/src/main/java/net/kdt/pojavlaunch/Tools.java @@ -31,6 +31,9 @@ import android.util.ArrayMap; import android.util.DisplayMetrics; import android.util.Log; import android.view.View; +import android.view.Window; +import android.view.WindowInsets; +import android.view.WindowInsetsController; import android.view.WindowManager; import android.widget.EditText; import android.widget.TextView; @@ -38,6 +41,7 @@ import android.widget.Toast; import androidx.annotation.NonNull; import androidx.annotation.Nullable; +import androidx.annotation.RequiresApi; import androidx.appcompat.app.AlertDialog; import androidx.appcompat.app.AppCompatActivity; import androidx.core.app.NotificationManagerCompat; @@ -504,10 +508,14 @@ public final class Tools { return displayMetrics; } - public static void setFullscreen(Activity activity, boolean fullscreen) { + @SuppressWarnings("deprecation") + private static void setFullscreenLegacy(Activity activity, boolean fullscreen) { final View decorView = activity.getWindow().getDecorView(); View.OnSystemUiVisibilityChangeListener visibilityChangeListener = visibility -> { - if(fullscreen){ + boolean multiWindowMode = SDK_INT >= 24 && activity.isInMultiWindowMode(); + // When in multi-window mode, asking for fullscreen makes no sense (cause the launcher runs in a window) + // So, ignore the fullscreen setting when activity is in multi window mode + if(fullscreen && !multiWindowMode){ if ((visibility & View.SYSTEM_UI_FLAG_FULLSCREEN) == 0) { decorView.setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_STABLE | View.SYSTEM_UI_FLAG_FULLSCREEN @@ -525,11 +533,67 @@ public final class Tools { visibilityChangeListener.onSystemUiVisibilityChange(decorView.getSystemUiVisibility()); //call it once since the UI state may not change after the call, so the activity wont become fullscreen } + @RequiresApi(Build.VERSION_CODES.R) + private static void setFullscreenSdk30(Activity activity, boolean fullscreen) { + final Window window = activity.getWindow(); + final View decorView = window.getDecorView(); + final int insetControllerFlags = WindowInsets.Type.statusBars() | WindowInsets.Type.navigationBars(); + final View.OnApplyWindowInsetsListener windowInsetsListener = (view, windowInsets) ->{ + WindowInsetsController windowInsetsController = decorView.getWindowInsetsController(); + if(windowInsetsController == null) return windowInsets; + boolean multiWindowMode = activity.isInMultiWindowMode(); + // Emulate the behaviour of the legacy function using the new flags + if(fullscreen && !multiWindowMode) { + windowInsetsController.hide(insetControllerFlags); + windowInsetsController.setSystemBarsBehavior(WindowInsetsController.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE); + window.setDecorFitsSystemWindows(false); + }else { + windowInsetsController.show(insetControllerFlags); + // Both of the constants below have the exact same numerical value, but + // for some reason the one that works below Android S was removed + // from the acceptable constants for setSystemBarsBehaviour + if (SDK_INT >= Build.VERSION_CODES.S) { + windowInsetsController.setSystemBarsBehavior(WindowInsetsController.BEHAVIOR_DEFAULT); + }else { + // noinspection WrongConstant + windowInsetsController.setSystemBarsBehavior(WindowInsetsController.BEHAVIOR_SHOW_BARS_BY_SWIPE); + } + window.setDecorFitsSystemWindows(true); + } + return windowInsets; + }; + decorView.setOnApplyWindowInsetsListener(windowInsetsListener); + windowInsetsListener.onApplyWindowInsets(decorView, null); + } + + public static void setFullscreen(Activity activity, boolean fullscreen) { + if (SDK_INT >= Build.VERSION_CODES.R) { + setFullscreenSdk30(activity, fullscreen); + }else { + setFullscreenLegacy(activity, fullscreen); + } + } + public static DisplayMetrics currentDisplayMetrics; public static void updateWindowSize(Activity activity) { currentDisplayMetrics = getDisplayMetrics(activity); + View dimensionView = activity.findViewById(R.id.dimension_tracker); + + if(dimensionView != null) { + int width = dimensionView.getWidth(); + int height = dimensionView.getHeight(); + if(width != 0 && height != 0) { + Log.i("Tools", "Using dimension_tracker for display dimensions; W="+width+" H="+height); + CallbackBridge.physicalWidth = width; + CallbackBridge.physicalHeight = height; + return; + }else{ + Log.e("Tools","Dimension tracker detected but dimensions out of date. Please check usage.", new Exception()); + } + } + CallbackBridge.physicalWidth = currentDisplayMetrics.widthPixels; CallbackBridge.physicalHeight = currentDisplayMetrics.heightPixels; } diff --git a/app_pojavlauncher/src/main/jni/egl_bridge.c b/app_pojavlauncher/src/main/jni/egl_bridge.c index 029bdeff3..30b89631b 100644 --- a/app_pojavlauncher/src/main/jni/egl_bridge.c +++ b/app_pojavlauncher/src/main/jni/egl_bridge.c @@ -212,11 +212,14 @@ int pojavInitOpenGL() { return 0; } +extern void updateMonitorSize(int width, int height); + EXTERNAL_API int pojavInit() { ANativeWindow_acquire(pojav_environ->pojavWindow); pojav_environ->savedWidth = ANativeWindow_getWidth(pojav_environ->pojavWindow); pojav_environ->savedHeight = ANativeWindow_getHeight(pojav_environ->pojavWindow); ANativeWindow_setBuffersGeometry(pojav_environ->pojavWindow,pojav_environ->savedWidth,pojav_environ->savedHeight,AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM); + updateMonitorSize(pojav_environ->savedWidth, pojav_environ->savedHeight); pojavInitOpenGL(); return 1; } diff --git a/app_pojavlauncher/src/main/jni/environ/environ.h b/app_pojavlauncher/src/main/jni/environ/environ.h index 4d73f1fb3..9e33e93d3 100644 --- a/app_pojavlauncher/src/main/jni/environ/environ.h +++ b/app_pojavlauncher/src/main/jni/environ/environ.h @@ -24,11 +24,9 @@ typedef void GLFW_invoke_Char_func(void* window, unsigned int codepoint); typedef void GLFW_invoke_CharMods_func(void* window, unsigned int codepoint, int mods); typedef void GLFW_invoke_CursorEnter_func(void* window, int entered); typedef void GLFW_invoke_CursorPos_func(void* window, double xpos, double ypos); -typedef void GLFW_invoke_FramebufferSize_func(void* window, int width, int height); typedef void GLFW_invoke_Key_func(void* window, int key, int scancode, int action, int mods); typedef void GLFW_invoke_MouseButton_func(void* window, int button, int action, int mods); typedef void GLFW_invoke_Scroll_func(void* window, double xoffset, double yoffset); -typedef void GLFW_invoke_WindowSize_func(void* window, int width, int height); struct pojav_environ_s { struct ANativeWindow* pojavWindow; @@ -46,6 +44,7 @@ struct pojav_environ_s { jmethodID method_onGrabStateChanged; jmethodID method_glftSetWindowAttrib; jmethodID method_internalWindowSizeChanged; + jmethodID method_internalChangeMonitorSize; jclass bridgeClazz; jclass vmGlfwClass; jboolean isGrabbing; @@ -56,7 +55,7 @@ struct pojav_environ_s { JavaVM* dalvikJavaVMPtr; JNIEnv* dalvikJNIEnvPtr_ANDROID; long showingWindow; - bool isInputReady, isCursorEntered, isUseStackQueueCall, shouldUpdateMouse; + bool isInputReady, isCursorEntered, isUseStackQueueCall, shouldUpdateMouse, shouldUpdateMonitorSize; int savedWidth, savedHeight; #define ADD_CALLBACK_WWIN(NAME) \ GLFW_invoke_##NAME##_func* GLFW_invoke_##NAME; @@ -64,11 +63,9 @@ struct pojav_environ_s { ADD_CALLBACK_WWIN(CharMods); ADD_CALLBACK_WWIN(CursorEnter); ADD_CALLBACK_WWIN(CursorPos); - ADD_CALLBACK_WWIN(FramebufferSize); ADD_CALLBACK_WWIN(Key); ADD_CALLBACK_WWIN(MouseButton); ADD_CALLBACK_WWIN(Scroll); - ADD_CALLBACK_WWIN(WindowSize); #undef ADD_CALLBACK_WWIN }; diff --git a/app_pojavlauncher/src/main/jni/input_bridge_v3.c b/app_pojavlauncher/src/main/jni/input_bridge_v3.c index 4dff47f36..9591d289d 100644 --- a/app_pojavlauncher/src/main/jni/input_bridge_v3.c +++ b/app_pojavlauncher/src/main/jni/input_bridge_v3.c @@ -26,11 +26,9 @@ #define EVENT_TYPE_CHAR 1000 #define EVENT_TYPE_CHAR_MODS 1001 #define EVENT_TYPE_CURSOR_ENTER 1002 -#define EVENT_TYPE_FRAMEBUFFER_SIZE 1004 #define EVENT_TYPE_KEY 1005 #define EVENT_TYPE_MOUSE_BUTTON 1006 #define EVENT_TYPE_SCROLL 1007 -#define EVENT_TYPE_WINDOW_SIZE 1008 jint (*orig_ProcessImpl_forkAndExec)(JNIEnv *env, jobject process, jint mode, jbyteArray helperpath, jbyteArray prog, jbyteArray argBlock, jint argc, jbyteArray envBlock, jint envc, jbyteArray dir, jintArray std_fds, jboolean redirectErrorStream); @@ -52,7 +50,8 @@ jint JNI_OnLoad(JavaVM* vm, __attribute__((unused)) void* reserved) { (*vm)->GetEnv(vm, (void**) &pojav_environ->runtimeJNIEnvPtr_JRE, JNI_VERSION_1_4); pojav_environ->vmGlfwClass = (*pojav_environ->runtimeJNIEnvPtr_JRE)->NewGlobalRef(pojav_environ->runtimeJNIEnvPtr_JRE, (*pojav_environ->runtimeJNIEnvPtr_JRE)->FindClass(pojav_environ->runtimeJNIEnvPtr_JRE, "org/lwjgl/glfw/GLFW")); pojav_environ->method_glftSetWindowAttrib = (*pojav_environ->runtimeJNIEnvPtr_JRE)->GetStaticMethodID(pojav_environ->runtimeJNIEnvPtr_JRE, pojav_environ->vmGlfwClass, "glfwSetWindowAttrib", "(JII)V"); - pojav_environ->method_internalWindowSizeChanged = (*pojav_environ->runtimeJNIEnvPtr_JRE)->GetStaticMethodID(pojav_environ->runtimeJNIEnvPtr_JRE, pojav_environ->vmGlfwClass, "internalWindowSizeChanged", "(JII)V"); + pojav_environ->method_internalWindowSizeChanged = (*pojav_environ->runtimeJNIEnvPtr_JRE)->GetStaticMethodID(pojav_environ->runtimeJNIEnvPtr_JRE, pojav_environ->vmGlfwClass, "internalWindowSizeChanged", "(J)V"); + pojav_environ->method_internalChangeMonitorSize = (*pojav_environ->runtimeJNIEnvPtr_JRE)->GetStaticMethodID(pojav_environ->runtimeJNIEnvPtr_JRE, pojav_environ->vmGlfwClass, "internalChangeMonitorSize", "(II)V"); jfieldID field_keyDownBuffer = (*pojav_environ->runtimeJNIEnvPtr_JRE)->GetStaticFieldID(pojav_environ->runtimeJNIEnvPtr_JRE, pojav_environ->vmGlfwClass, "keyDownBuffer", "Ljava/nio/ByteBuffer;"); jobject keyDownBufferJ = (*pojav_environ->runtimeJNIEnvPtr_JRE)->GetStaticObjectField(pojav_environ->runtimeJNIEnvPtr_JRE, pojav_environ->vmGlfwClass, field_keyDownBuffer); pojav_environ->keyDownBuffer = (*pojav_environ->runtimeJNIEnvPtr_JRE)->GetDirectBufferAddress(pojav_environ->runtimeJNIEnvPtr_JRE, keyDownBufferJ); @@ -86,16 +85,17 @@ ADD_CALLBACK_WWIN(Char) ADD_CALLBACK_WWIN(CharMods) ADD_CALLBACK_WWIN(CursorEnter) ADD_CALLBACK_WWIN(CursorPos) -ADD_CALLBACK_WWIN(FramebufferSize) ADD_CALLBACK_WWIN(Key) ADD_CALLBACK_WWIN(MouseButton) ADD_CALLBACK_WWIN(Scroll) -ADD_CALLBACK_WWIN(WindowSize) #undef ADD_CALLBACK_WWIN -void handleFramebufferSizeJava(long window, int w, int h) { - (*pojav_environ->runtimeJNIEnvPtr_JRE)->CallStaticVoidMethod(pojav_environ->runtimeJNIEnvPtr_JRE, pojav_environ->vmGlfwClass, pojav_environ->method_internalWindowSizeChanged, (long)window, w, h); +void updateMonitorSize(int width, int height) { + (*pojav_environ->runtimeJNIEnvPtr_JRE)->CallStaticVoidMethod(pojav_environ->runtimeJNIEnvPtr_JRE, pojav_environ->vmGlfwClass, pojav_environ->method_internalChangeMonitorSize, width, height); +} +void updateWindowSize(void* window) { + (*pojav_environ->runtimeJNIEnvPtr_JRE)->CallStaticVoidMethod(pojav_environ->runtimeJNIEnvPtr_JRE, pojav_environ->vmGlfwClass, pojav_environ->method_internalWindowSizeChanged, (long)window); } void pojavPumpEvents(void* window) { @@ -103,6 +103,9 @@ void pojavPumpEvents(void* window) { pojav_environ->GLFW_invoke_CursorPos(window, floor(pojav_environ->cursorX), floor(pojav_environ->cursorY)); } + if(pojav_environ->shouldUpdateMonitorSize) { + updateWindowSize(window); + } size_t index = pojav_environ->outEventIndex; size_t targetIndex = pojav_environ->outTargetIndex; @@ -125,14 +128,6 @@ void pojavPumpEvents(void* window) { case EVENT_TYPE_SCROLL: if(pojav_environ->GLFW_invoke_Scroll) pojav_environ->GLFW_invoke_Scroll(window, event.i1, event.i2); break; - case EVENT_TYPE_FRAMEBUFFER_SIZE: - handleFramebufferSizeJava(pojav_environ->showingWindow, event.i1, event.i2); - if(pojav_environ->GLFW_invoke_FramebufferSize) pojav_environ->GLFW_invoke_FramebufferSize(window, event.i1, event.i2); - break; - case EVENT_TYPE_WINDOW_SIZE: - handleFramebufferSizeJava(pojav_environ->showingWindow, event.i1, event.i2); - if(pojav_environ->GLFW_invoke_WindowSize) pojav_environ->GLFW_invoke_WindowSize(window, event.i1, event.i2); - break; } index++; @@ -162,6 +157,10 @@ void pojavStartPumping() { pojav_environ->cLastY = pojav_environ->cursorY; pojav_environ->shouldUpdateMouse = true; } + if(pojav_environ->shouldUpdateMonitorSize) { + // Perform a monitor size update here to avoid doing it on every single window + updateMonitorSize(pojav_environ->savedWidth, pojav_environ->savedHeight); + } } /** Prepare the library for the next round of new events */ @@ -170,8 +169,9 @@ void pojavStopPumping() { // New events may have arrived while pumping, so remove only the difference before the start and end of execution atomic_fetch_sub_explicit(&pojav_environ->eventCounter, pojav_environ->inEventCount, memory_order_acquire); - // Make sure the next frame won't send mouse updates if it's unnecessary + // Make sure the next frame won't send mouse or monitor updates if it's unnecessary pojav_environ->shouldUpdateMouse = false; + pojav_environ->shouldUpdateMonitorSize = false; } JNIEXPORT void JNICALL @@ -502,23 +502,11 @@ void noncritical_send_mouse_button(__attribute__((unused)) JNIEnv* env, __attrib void critical_send_screen_size(jint width, jint height) { pojav_environ->savedWidth = width; pojav_environ->savedHeight = height; - if (pojav_environ->isInputReady) { - if (pojav_environ->GLFW_invoke_FramebufferSize) { - if (pojav_environ->isUseStackQueueCall) { - sendData(EVENT_TYPE_FRAMEBUFFER_SIZE, width, height, 0, 0); - } else { - pojav_environ->GLFW_invoke_FramebufferSize((void*) pojav_environ->showingWindow, width, height); - } - } - - if (pojav_environ->GLFW_invoke_WindowSize) { - if (pojav_environ->isUseStackQueueCall) { - sendData(EVENT_TYPE_WINDOW_SIZE, width, height, 0, 0); - } else { - pojav_environ->GLFW_invoke_WindowSize((void*) pojav_environ->showingWindow, width, height); - } - } - } + pojav_environ->shouldUpdateMonitorSize = true; + // Don't use the direct updates for screen dimensions. + // This is done to ensure that we have predictable conditions to correctly call + // updateMonitorSize() and updateWindowSize() while on the render thread with an attached + // JNIEnv. } void noncritical_send_screen_size(__attribute__((unused)) JNIEnv* env, __attribute__((unused)) jclass clazz, jint width, jint height) { diff --git a/app_pojavlauncher/src/main/res/layout/activity_basemain.xml b/app_pojavlauncher/src/main/res/layout/activity_basemain.xml index c97c03d06..ae0d0ed15 100644 --- a/app_pojavlauncher/src/main/res/layout/activity_basemain.xml +++ b/app_pojavlauncher/src/main/res/layout/activity_basemain.xml @@ -20,6 +20,8 @@ android:layout_width="match_parent" android:layout_height="match_parent"> + + ?android:attr/listDivider + + diff --git a/jre_lwjgl3glfw/src/main/java/org/lwjgl/glfw/GLFW.java b/jre_lwjgl3glfw/src/main/java/org/lwjgl/glfw/GLFW.java index dde2f39ba..cf651e5b7 100644 --- a/jre_lwjgl3glfw/src/main/java/org/lwjgl/glfw/GLFW.java +++ b/jre_lwjgl3glfw/src/main/java/org/lwjgl/glfw/GLFW.java @@ -478,7 +478,6 @@ public class GLFW /* volatile */ public static GLFWCursorPosCallback mGLFWCursorPosCallback; /* volatile */ public static GLFWDropCallback mGLFWDropCallback; /* volatile */ public static GLFWErrorCallback mGLFWErrorCallback; - /* volatile */ public static GLFWFramebufferSizeCallback mGLFWFramebufferSizeCallback; /* volatile */ public static GLFWJoystickCallback mGLFWJoystickCallback; /* volatile */ public static GLFWKeyCallback mGLFWKeyCallback; /* volatile */ public static GLFWMonitorCallback mGLFWMonitorCallback; @@ -491,7 +490,11 @@ public class GLFW /* volatile */ public static GLFWWindowMaximizeCallback mGLFWWindowMaximizeCallback; /* volatile */ public static GLFWWindowPosCallback mGLFWWindowPosCallback; /* volatile */ public static GLFWWindowRefreshCallback mGLFWWindowRefreshCallback; - /* volatile */ public static GLFWWindowSizeCallback mGLFWWindowSizeCallback; + + // Store callback method references directly to avoid a roundtrip through + // JNI when calling the default LWJGL callbacks. + @Nullable public static GLFWFramebufferSizeCallbackI mGLFWFramebufferSizeCallbackI; + @Nullable public static GLFWWindowSizeCallbackI mGLFWWindowSizeCallbackI; volatile public static int mGLFWWindowWidth, mGLFWWindowHeight; @@ -513,22 +516,6 @@ public class GLFW public static long mainContext = 0; static { - String windowWidth = System.getProperty(PROP_WINDOW_WIDTH); - String windowHeight = System.getProperty(PROP_WINDOW_HEIGHT); - if (windowWidth == null || windowHeight == null) { - System.err.println("Warning: Property " + PROP_WINDOW_WIDTH + " or " + PROP_WINDOW_HEIGHT + " not set, defaulting to 1280 and 720"); - - mGLFWWindowWidth = 1280; - mGLFWWindowHeight = 720; - } else { - mGLFWWindowWidth = Integer.parseInt(windowWidth); - mGLFWWindowHeight = Integer.parseInt(windowHeight); - } - - // Minecraft triggers a glfwPollEvents() on splash screen, so update window size there. - // CallbackBridge.receiveCallback(CallbackBridge.EVENT_TYPE_FRAMEBUFFER_SIZE, mGLFWWindowWidth, mGLFWWindowHeight, 0, 0); - // CallbackBridge.receiveCallback(CallbackBridge.EVENT_TYPE_WINDOW_SIZE, mGLFWWindowWidth, mGLFWWindowHeight, 0, 0); - try { System.loadLibrary("pojavexec"); } catch (UnsatisfiedLinkError e) { @@ -582,11 +569,9 @@ public class GLFW private static native long nglfwSetCharModsCallback(long window, long ptr); private static native long nglfwSetCursorEnterCallback(long window, long ptr); private static native long nglfwSetCursorPosCallback(long window, long ptr); - private static native long nglfwSetFramebufferSizeCallback(long window, long ptr); private static native long nglfwSetKeyCallback(long window, long ptr); private static native long nglfwSetMouseButtonCallback(long window, long ptr); private static native long nglfwSetScrollCallback(long window, long ptr); - private static native long nglfwSetWindowSizeCallback(long window, long ptr); // private static native void nglfwSetInputReady(); private static native void nglfwSetShowingWindow(long window); @@ -633,6 +618,7 @@ public class GLFW return GLFW; } + @SuppressWarnings("unused") // Used by pojavexec public static void internalChangeMonitorSize(int width, int height) { mGLFWWindowWidth = width; mGLFWWindowHeight = height; @@ -699,11 +685,12 @@ public class GLFW } public static GLFWFramebufferSizeCallback glfwSetFramebufferSizeCallback(@NativeType("GLFWwindow *") long window, @Nullable @NativeType("GLFWframebuffersizefun") GLFWFramebufferSizeCallbackI cbfun) { - GLFWFramebufferSizeCallback lastCallback = mGLFWFramebufferSizeCallback; - if (cbfun == null) mGLFWFramebufferSizeCallback = null; - else mGLFWFramebufferSizeCallback = GLFWFramebufferSizeCallback.createSafe(nglfwSetFramebufferSizeCallback(window, memAddressSafe(cbfun))); - - return lastCallback; + GLFWFramebufferSizeCallback previousCallback = null; + if(mGLFWFramebufferSizeCallbackI != null) { + previousCallback = GLFWFramebufferSizeCallback.create(mGLFWFramebufferSizeCallbackI); + } + mGLFWFramebufferSizeCallbackI = cbfun; + return previousCallback; } public static GLFWJoystickCallback glfwSetJoystickCallback(/* @NativeType("GLFWwindow *") long window, */ @Nullable @NativeType("GLFWjoystickfun") GLFWJoystickCallbackI cbfun) { @@ -802,11 +789,12 @@ public class GLFW } public static GLFWWindowSizeCallback glfwSetWindowSizeCallback(@NativeType("GLFWwindow *") long window, @Nullable @NativeType("GLFWwindowsizefun") GLFWWindowSizeCallbackI cbfun) { - GLFWWindowSizeCallback lastCallback = mGLFWWindowSizeCallback; - if (cbfun == null) mGLFWWindowSizeCallback = null; - else mGLFWWindowSizeCallback = GLFWWindowSizeCallback.createSafe(nglfwSetWindowSizeCallback(window, memAddressSafe(cbfun))); - - return lastCallback; + GLFWWindowSizeCallback previousCallback = null; + if(mGLFWWindowSizeCallbackI != null) { + previousCallback = GLFWWindowSizeCallback.create(mGLFWWindowSizeCallbackI); + } + mGLFWWindowSizeCallbackI = cbfun; + return previousCallback; } static boolean isGLFWReady; @@ -1088,11 +1076,12 @@ public class GLFW callV(Functions.StopPumping); mGLFWInputPumping = false; } - - public static void internalWindowSizeChanged(long window, int w, int h) { + @SuppressWarnings("unused") // Used by pojavexec + public static void internalWindowSizeChanged(long window) { try { - internalChangeMonitorSize(w, h); glfwSetWindowSize(window, mGLFWWindowWidth, mGLFWWindowHeight); + if(mGLFWFramebufferSizeCallbackI != null) mGLFWFramebufferSizeCallbackI.invoke(window, mGLFWWindowWidth, mGLFWWindowHeight); + if(mGLFWWindowSizeCallbackI != null) mGLFWWindowSizeCallbackI.invoke(window, mGLFWWindowWidth, mGLFWWindowHeight); }catch (Exception e) { e.printStackTrace(); }