Support multi-threaded rendering with OpenGL on Android

dsnopek · dsnopek · commit d8eea1ea1c5e · 2025-08-08T15:13:43.000-05:00
diff --git a/platform/android/display_server_android.cpp b/platform/android/display_server_android.cpp
@@ -485,24 +485,16 @@ int64_t DisplayServerAndroid::window_get_native_handle(HandleType p_handle_type,
 		}
 #ifdef GLES3_ENABLED
 		case DISPLAY_HANDLE: {
-			if (rendering_driver == "opengl3") {
-				return reinterpret_cast<int64_t>(eglGetCurrentDisplay());
-			}
-			return 0;
+			return reinterpret_cast<int64_t>(egl_display);
 		}
 		case OPENGL_CONTEXT: {
-			if (rendering_driver == "opengl3") {
-				return reinterpret_cast<int64_t>(eglGetCurrentContext());
-			}
-			return 0;
+			return reinterpret_cast<int64_t>(egl_context);
 		}
 		case EGL_DISPLAY: {
-			// @todo Find a way to get this from the Java side.
-			return 0;
+			return reinterpret_cast<int64_t>(egl_display);
 		}
 		case EGL_CONFIG: {
-			// @todo Find a way to get this from the Java side.
-			return 0;
+			return reinterpret_cast<int64_t>(egl_config);
 		}
 #endif
 		default: {
@@ -715,6 +707,15 @@ void DisplayServerAndroid::notify_surface_changed(int p_width, int p_height) {
 	}
 }
 
+void DisplayServerAndroid::update_egl_resources(void *p_display, void *p_surface, void *p_context, void *p_config) {
+#ifdef GLES3_ENABLED
+	egl_display = p_display;
+	egl_surface = p_surface;
+	egl_context = p_context;
+	egl_config = p_config;
+#endif
+}
+
 DisplayServerAndroid::DisplayServerAndroid(const String &p_rendering_driver, DisplayServer::WindowMode p_mode, DisplayServer::VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i *p_position, const Vector2i &p_resolution, int p_screen, Context p_context, int64_t p_parent_window, Error &r_error) {
 	rendering_driver = p_rendering_driver;
 
@@ -796,6 +797,11 @@ DisplayServerAndroid::DisplayServerAndroid(const String &p_rendering_driver, Dis
 #if defined(GLES3_ENABLED)
 	if (rendering_driver == "opengl3") {
 		RasterizerGLES3::make_current(false);
+
+		if (OS::get_singleton()->is_separate_thread_rendering_enabled()) {
+			GodotJavaWrapper *godot_java = OS_Android::get_singleton()->get_godot_java();
+			godot_java->set_separate_render_thread_enabled(true);
+		}
 	}
 #endif
 
@@ -962,6 +968,7 @@ void DisplayServerAndroid::release_rendering_thread() {
 	GodotJavaWrapper *godot_java = OS_Android::get_singleton()->get_godot_java();
 	ERR_FAIL_NULL(godot_java);
 	godot_java->release_current_gl_window(egl_current_window_id);
+	egl_current_window_id = INVALID_WINDOW_ID;
 }
 
 void DisplayServerAndroid::swap_buffers() {
diff --git a/platform/android/display_server_android.h b/platform/android/display_server_android.h
@@ -79,6 +79,14 @@ class DisplayServerAndroid : public DisplayServer {
 	RenderingContextDriver *rendering_context = nullptr;
 	RenderingDevice *rendering_device = nullptr;
 #endif
+
+#ifdef GLES3_ENABLED
+	void *egl_display = nullptr;
+	void *egl_surface = nullptr;
+	void *egl_context = nullptr;
+	void *egl_config = nullptr;
+#endif
+
 	NativeMenu *native_menu = nullptr;
 
 	ObjectID window_attached_instance_id;
@@ -245,6 +253,7 @@ class DisplayServerAndroid : public DisplayServer {
 
 	void reset_window();
 	void notify_surface_changed(int p_width, int p_height);
+	void update_egl_resources(void *p_display, void *p_surface, void *p_context, void *p_config);
 
 	virtual Point2i mouse_get_position() const override;
 	virtual BitField<MouseButtonMask> mouse_get_button_state() const override;
diff --git a/platform/android/java/lib/src/org/godotengine/godot/Godot.kt b/platform/android/java/lib/src/org/godotengine/godot/Godot.kt
@@ -1382,6 +1382,11 @@ class Godot private constructor(val context: Context) {
 		renderView?.view?.pointerIcon = pointerIcon
 	}
 
+	@Keep
+	private fun setSeparateRenderThreadEnabled(enabled: Boolean) {
+		renderer.renderThread.setSeparateRenderThreadEnabled(enabled)
+	}
+
 	@Keep
 	private fun makeGLWindowCurrent(windowId: Int): Boolean {
 		return renderer.renderThread.makeEglCurrent(windowId)
diff --git a/platform/android/java/lib/src/org/godotengine/godot/GodotLib.java b/platform/android/java/lib/src/org/godotengine/godot/GodotLib.java
@@ -89,6 +89,11 @@ public static native boolean initialize(
 	 */
 	public static native void newcontext(Surface p_surface);
 
+	/**
+	 * Invoked on the render thread when any of the EGL resources may have changed.
+	 */
+	public static native void updateEglResources(long display, long surface, long context, long config);
+
 	/**
 	 * Forward {@link Activity#onBackPressed()} event.
 	 */
diff --git a/platform/android/java/lib/src/org/godotengine/godot/render/GLSurfaceView.java b/platform/android/java/lib/src/org/godotengine/godot/render/GLSurfaceView.java
@@ -815,7 +815,7 @@ public void start() {
 		 *
 		 * @return true if the surface was created successfully.
 		 */
-		public boolean createSurface() {
+		public boolean createSurface(boolean requireMakeCurrent) {
 			if (LOG_EGL) {
 				Log.w("EglHelper", "createSurface()  tid=" + Thread.currentThread().getId());
 			}
@@ -854,7 +854,7 @@ public boolean createSurface() {
 				return false;
 			}
 
-			if (!makeEglCurrent()) {
+			if (!makeEglCurrent() && requireMakeCurrent) {
 				return false;
 			}
 
@@ -1261,11 +1261,13 @@ private void guardedRun() throws InterruptedException {
 					}
 
 					if (mRegisteredGLSurface != null) {
+						boolean eglResourcesChanged = false;
+
 						if (mRegisteredGLSurface.mFrameParams.createEglSurface) {
 							if (LOG_SURFACE) {
 								Log.w("GLThread", "egl createSurface");
 							}
-							if (mRegisteredGLSurface.mEglHelper.createSurface()) {
+							if (mRegisteredGLSurface.mEglHelper.createSurface(!mSeparateRenderThreadEnabled)) {
 								synchronized (sGLThreadManager) {
 									mRegisteredGLSurface.mFinishedCreatingEglSurface = true;
 									sGLThreadManager.notifyAll();
@@ -1278,6 +1280,7 @@ private void guardedRun() throws InterruptedException {
 								}
 								continue;
 							}
+							eglResourcesChanged = true;
 							mRegisteredGLSurface.mFrameParams.createEglSurface = false;
 						}
 
@@ -1302,6 +1305,10 @@ private void guardedRun() throws InterruptedException {
 							}
 							mRegisteredGLSurface.mFrameParams.sizeChanged = false;
 						}
+
+						if (eglResourcesChanged) {
+							mRenderer.onRenderEglResourcesChanged(mRegisteredGLSurface.mEglHelper.mEglDisplay, mRegisteredGLSurface.mEglHelper.mEglSurface, mRegisteredGLSurface.mEglHelper.mEglContext, mRegisteredGLSurface.mEglHelper.mEglConfig);
+						}
 					}
 
 					if (LOG_RENDERER_DRAW_FRAME) {
@@ -1588,6 +1595,13 @@ public void queueEvent(Runnable r) {
 			}
 		}
 
+		@Override
+		public void setSeparateRenderThreadEnabled(boolean enabled) {
+			synchronized(sGLThreadManager) {
+				mSeparateRenderThreadEnabled = enabled;
+			}
+		}
+
 		@Override
 		public boolean makeEglCurrent(int id) {
 			synchronized (sGLThreadManager) {
@@ -1640,6 +1654,7 @@ public void releaseCurrentGLWindow(int id) {
 		private boolean mRequestRender;
 		private boolean mWantRenderNotification;
 		private boolean mRenderComplete;
+		private boolean mSeparateRenderThreadEnabled;
 		private final ArrayList<Runnable> mEventQueue = new ArrayList<Runnable>();
 		private Runnable mFinishDrawingRunnable = null;
 		private final GodotRenderer mRenderer;
diff --git a/platform/android/java/lib/src/org/godotengine/godot/render/GodotRenderer.kt b/platform/android/java/lib/src/org/godotengine/godot/render/GodotRenderer.kt
@@ -37,6 +37,10 @@ import android.view.Surface
 import org.godotengine.godot.GodotLib
 import org.godotengine.godot.plugin.GodotPluginRegistry
 import org.godotengine.godot.render.GLSurfaceView.GLThread
+import android.opengl.EGLConfig;
+import android.opengl.EGLContext;
+import android.opengl.EGLDisplay;
+import android.opengl.EGLSurface;
 
 /**
  * Responsible for setting up and driving Godot rendering logic.
@@ -260,4 +264,9 @@ internal class GodotRenderer(val useVulkan: Boolean) : Renderer {
 			plugin.onRenderSurfaceCreated(surface)
 		}
 	}
+
+	override fun onRenderEglResourcesChanged(display: EGLDisplay?, surface: EGLSurface?, context: EGLContext?, config: EGLConfig?) {
+		GodotLib.updateEglResources(display?.getNativeHandle() ?: 0L, surface?.getNativeHandle() ?: 0L, context?.getNativeHandle() ?: 0L, config?.getNativeHandle() ?: 0L);
+	}
+
 }
diff --git a/platform/android/java/lib/src/org/godotengine/godot/render/RenderThread.kt b/platform/android/java/lib/src/org/godotengine/godot/render/RenderThread.kt
@@ -80,6 +80,8 @@ internal abstract class RenderThread(tag: String) : Thread(tag) {
 	 */
 	open fun surfaceDestroyed(holder: SurfaceHolder) { }
 
+	open fun setSeparateRenderThreadEnabled(enabled: Boolean) {}
+
 	open fun makeEglCurrent(windowId: Int): Boolean = false
 
 	open fun eglSwapBuffers(windowId: Int) {}
diff --git a/platform/android/java/lib/src/org/godotengine/godot/render/Renderer.java b/platform/android/java/lib/src/org/godotengine/godot/render/Renderer.java
@@ -30,6 +30,10 @@
 
 package org.godotengine.godot.render;
 
+import android.opengl.EGLConfig;
+import android.opengl.EGLContext;
+import android.opengl.EGLDisplay;
+import android.opengl.EGLSurface;
 import android.view.Surface;
 
 import androidx.annotation.NonNull;
@@ -124,4 +128,9 @@ enum RenderMode {
 	 * Invoked when the render thread is in the process of shutting down.
 	 */
 	void onRenderThreadExiting();
+
+	/**
+	 * Invoked when any of the EGL resources may have changed.
+	 */
+	void onRenderEglResourcesChanged(EGLDisplay display, EGLSurface surface, EGLContext context, EGLConfig config);
 }
diff --git a/platform/android/java_godot_lib_jni.cpp b/platform/android/java_godot_lib_jni.cpp
@@ -245,6 +245,12 @@ JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_newcontext(JNIEnv *en
 	}
 }
 
+JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_updateEglResources(JNIEnv *env, jlong p_display, jlong p_surface, jlong p_context, jlong p_config) {
+	if (DisplayServerAndroid *dsa = DisplayServerAndroid::get_singleton()) {
+		dsa->update_egl_resources(reinterpret_cast<void *>(p_display), reinterpret_cast<void *>(p_surface), reinterpret_cast<void *>(p_context), reinterpret_cast<void *>(p_config));
+	}
+}
+
 JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_back(JNIEnv *env, jclass clazz) {
 	if (step.get() <= STEP_SETUP) {
 		return;
diff --git a/platform/android/java_godot_lib_jni.h b/platform/android/java_godot_lib_jni.h
@@ -41,6 +41,7 @@ JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_ondestroy(JNIEnv *env
 JNIEXPORT jboolean JNICALL Java_org_godotengine_godot_GodotLib_setup(JNIEnv *env, jclass clazz, jobjectArray p_cmdline, jobject p_godot_tts);
 JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_resize(JNIEnv *env, jclass clazz, jobject p_surface, jint p_width, jint p_height);
 JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_newcontext(JNIEnv *env, jclass clazz, jobject p_surface);
+JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_updateEglResources(JNIEnv *env, jlong p_display, jlong p_surface, jlong p_context, jlong p_config);
 JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_step(JNIEnv *env, jclass clazz);
 JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_ttsCallback(JNIEnv *env, jclass clazz, jint event, jint id, jint pos);
 JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_back(JNIEnv *env, jclass clazz);
diff --git a/platform/android/java_godot_wrapper.cpp b/platform/android/java_godot_wrapper.cpp
@@ -96,6 +96,7 @@ GodotJavaWrapper::GodotJavaWrapper(JNIEnv *p_env, jobject p_godot_instance) {
 		_release_pointer_capture = p_env->GetMethodID(godot_class, "releasePointerCapture", "()V");
 	}
 
+	_set_separate_render_thread_enabled = p_env->GetMethodID(godot_class, "setSeparateRenderThreadEnabled", "(Z)V");
 	_make_gl_window_current = p_env->GetMethodID(godot_class, "makeGLWindowCurrent", "(I)Z");
 	_egl_swap_buffers = p_env->GetMethodID(godot_class, "eglSwapBuffers", "(I)V");
 	_release_current_gl_window = p_env->GetMethodID(godot_class, "releaseCurrentGLWindow", "(I)V");
@@ -641,6 +642,15 @@ void GodotJavaWrapper::set_pointer_icon(int pointer_type) {
 	}
 }
 
+void GodotJavaWrapper::set_separate_render_thread_enabled(bool p_enabled) {
+	if (_set_separate_render_thread_enabled != nullptr) {
+		JNIEnv *env = get_jni_env();
+		ERR_FAIL_NULL(env);
+
+		env->CallVoidMethod(godot_instance, _set_separate_render_thread_enabled, p_enabled);
+	}
+}
+
 bool GodotJavaWrapper::make_gl_window_current(DisplayServer::WindowID p_window_id) {
 	if (_make_gl_window_current != nullptr) {
 		JNIEnv *env = get_jni_env();
diff --git a/platform/android/java_godot_wrapper.h b/platform/android/java_godot_wrapper.h
@@ -86,6 +86,7 @@ class GodotJavaWrapper {
 	jmethodID _release_pointer_capture = nullptr;
 	jmethodID _configure_pointer_icon = nullptr;
 	jmethodID _set_pointer_icon = nullptr;
+	jmethodID _set_separate_render_thread_enabled = nullptr;
 	jmethodID _make_gl_window_current = nullptr;
 	jmethodID _egl_swap_buffers = nullptr;
 	jmethodID _release_current_gl_window = nullptr;
@@ -149,6 +150,7 @@ class GodotJavaWrapper {
 	void configure_pointer_icon(int pointer_type, const String &image_path, const Vector2 &p_hotspot);
 	void set_pointer_icon(int pointer_type);
 
+	void set_separate_render_thread_enabled(bool p_enabled);
 	bool make_gl_window_current(DisplayServer::WindowID p_window_id);
 	void egl_swap_buffers(DisplayServer::WindowID p_window_id);
 	void release_current_gl_window(DisplayServer::WindowID p_window_id);

Original file line number	Diff line number	Diff line change
`@@ -815,7 +815,7 @@ public void start() {`
`815`	`815`	`*`
`816`	`816`	`* @return true if the surface was created successfully.`
`817`	`817`	`*/`
`818`		`- public boolean createSurface() {`
	`818`	`+ public boolean createSurface(boolean requireMakeCurrent) {`
`819`	`819`	`if (LOG_EGL) {`
`820`	`820`	`Log.w("EglHelper", "createSurface() tid=" + Thread.currentThread().getId());`
`821`	`821`	`}`
`@@ -854,7 +854,7 @@ public boolean createSurface() {`
`854`	`854`	`return false;`
`855`	`855`	`}`
`856`	`856`
`857`		`- if (!makeEglCurrent()) {`
	`857`	`+ if (!makeEglCurrent() && requireMakeCurrent) {`
`858`	`858`	`return false;`
`859`	`859`	`}`
`860`	`860`
`@@ -1261,11 +1261,13 @@ private void guardedRun() throws InterruptedException {`
`1261`	`1261`	`}`
`1262`	`1262`
`1263`	`1263`	`if (mRegisteredGLSurface != null) {`
	`1264`	`+ boolean eglResourcesChanged = false;`
	`1265`	`+`
`1264`	`1266`	`if (mRegisteredGLSurface.mFrameParams.createEglSurface) {`
`1265`	`1267`	`if (LOG_SURFACE) {`
`1266`	`1268`	`Log.w("GLThread", "egl createSurface");`
`1267`	`1269`	`}`
`1268`		`- if (mRegisteredGLSurface.mEglHelper.createSurface()) {`
	`1270`	`+ if (mRegisteredGLSurface.mEglHelper.createSurface(!mSeparateRenderThreadEnabled)) {`
`1269`	`1271`	`synchronized (sGLThreadManager) {`
`1270`	`1272`	`mRegisteredGLSurface.mFinishedCreatingEglSurface = true;`
`1271`	`1273`	`sGLThreadManager.notifyAll();`
`@@ -1278,6 +1280,7 @@ private void guardedRun() throws InterruptedException {`
`1278`	`1280`	`}`
`1279`	`1281`	`continue;`
`1280`	`1282`	`}`
	`1283`	`+ eglResourcesChanged = true;`
`1281`	`1284`	`mRegisteredGLSurface.mFrameParams.createEglSurface = false;`
`1282`	`1285`	`}`
`1283`	`1286`
`@@ -1302,6 +1305,10 @@ private void guardedRun() throws InterruptedException {`
`1302`	`1305`	`}`
`1303`	`1306`	`mRegisteredGLSurface.mFrameParams.sizeChanged = false;`
`1304`	`1307`	`}`
	`1308`	`+`
	`1309`	`+ if (eglResourcesChanged) {`
	`1310`	`+ mRenderer.onRenderEglResourcesChanged(mRegisteredGLSurface.mEglHelper.mEglDisplay, mRegisteredGLSurface.mEglHelper.mEglSurface, mRegisteredGLSurface.mEglHelper.mEglContext, mRegisteredGLSurface.mEglHelper.mEglConfig);`
	`1311`	`+ }`
`1305`	`1312`	`}`
`1306`	`1313`
`1307`	`1314`	`if (LOG_RENDERER_DRAW_FRAME) {`
`@@ -1588,6 +1595,13 @@ public void queueEvent(Runnable r) {`
`1588`	`1595`	`}`
`1589`	`1596`	`}`
`1590`	`1597`
	`1598`	`+ @Override`
	`1599`	`+ public void setSeparateRenderThreadEnabled(boolean enabled) {`
	`1600`	`+ synchronized(sGLThreadManager) {`
	`1601`	`+ mSeparateRenderThreadEnabled = enabled;`
	`1602`	`+ }`
	`1603`	`+ }`
	`1604`	`+`
`1591`	`1605`	`@Override`
`1592`	`1606`	`public boolean makeEglCurrent(int id) {`
`1593`	`1607`	`synchronized (sGLThreadManager) {`
`@@ -1640,6 +1654,7 @@ public void releaseCurrentGLWindow(int id) {`
`1640`	`1654`	`private boolean mRequestRender;`
`1641`	`1655`	`private boolean mWantRenderNotification;`
`1642`	`1656`	`private boolean mRenderComplete;`
	`1657`	`+ private boolean mSeparateRenderThreadEnabled;`
`1643`	`1658`	`private final ArrayList<Runnable> mEventQueue = new ArrayList<Runnable>();`
`1644`	`1659`	`private Runnable mFinishDrawingRunnable = null;`
`1645`	`1660`	`private final GodotRenderer mRenderer;`
Original file line number	Diff line number	Diff line change
`@@ -37,6 +37,10 @@ import android.view.Surface`
`37`	`37`	`import org.godotengine.godot.GodotLib`
`38`	`38`	`import org.godotengine.godot.plugin.GodotPluginRegistry`
`39`	`39`	`import org.godotengine.godot.render.GLSurfaceView.GLThread`
	`40`	`+import android.opengl.EGLConfig;`
	`41`	`+import android.opengl.EGLContext;`
	`42`	`+import android.opengl.EGLDisplay;`
	`43`	`+import android.opengl.EGLSurface;`
`40`	`44`
`41`	`45`	`/**`
`42`	`46`	`* Responsible for setting up and driving Godot rendering logic.`
`@@ -260,4 +264,9 @@ internal class GodotRenderer(val useVulkan: Boolean) : Renderer {`
`260`	`264`	`plugin.onRenderSurfaceCreated(surface)`
`261`	`265`	`}`
`262`	`266`	`}`
	`267`	`+`
	`268`	`+ override fun onRenderEglResourcesChanged(display: EGLDisplay?, surface: EGLSurface?, context: EGLContext?, config: EGLConfig?) {`
	`269`	`+ GodotLib.updateEglResources(display?.getNativeHandle() ?: 0L, surface?.getNativeHandle() ?: 0L, context?.getNativeHandle() ?: 0L, config?.getNativeHandle() ?: 0L);`
	`270`	`+ }`
	`271`	`+`
`263`	`272`	`}`
Original file line number	Diff line number	Diff line change
`@@ -245,6 +245,12 @@ JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_newcontext(JNIEnv *en`
`245`	`245`	`}`
`246`	`246`	`}`
`247`	`247`
	`248`	`+JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_updateEglResources(JNIEnv *env, jlong p_display, jlong p_surface, jlong p_context, jlong p_config) {`
	`249`	`+ if (DisplayServerAndroid *dsa = DisplayServerAndroid::get_singleton()) {`
	`250`	`+ dsa->update_egl_resources(reinterpret_cast<void >(p_display), reinterpret_cast<void >(p_surface), reinterpret_cast<void >(p_context), reinterpret_cast<void >(p_config));`
	`251`	`+ }`
	`252`	`+}`
	`253`	`+`
`248`	`254`	`JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_back(JNIEnv *env, jclass clazz) {`
`249`	`255`	`if (step.get() <= STEP_SETUP) {`
`250`	`256`	`return;`