Windows VR support for headset immersive mode (opt-in)

app/build.gradle.kts

@@ -271,7 +271,7 @@ android {
                 srcDirs("src/modern/assets", "src/main/assets")
             }
             jniLibs {
-                srcDirs("src/modern/jniLibs")
+                setSrcDirs(listOf("src/modern/jniLibs", "src/modernXr/jniLibs"))
             }
         }
         getByName("debug") {
@@ -283,6 +283,76 @@ android {
         ignoreFormatFailures  = false
     }
 
+    val hostCanRunXrPayloadScripts = System.getProperty("os.name").startsWith("Windows")
+
+    tasks.register<Exec>("buildModernXrNative") {
+        enabled = hostCanRunXrPayloadScripts
+        commandLine(
+            "powershell",
+            "-ExecutionPolicy",
+            "Bypass",
+            "-File",
+            rootProject.file("tools/build-xr-native.ps1").absolutePath,
+        )
+    }
+
+    tasks.register<Exec>("buildWindowsXrRuntime") {
+        enabled = hostCanRunXrPayloadScripts
+        commandLine(
+            "powershell",
+            "-ExecutionPolicy",
+            "Bypass",
+            "-File",
+            rootProject.file("tools/build-windows-xr-runtime.ps1").absolutePath,
+        )
+    }
+
+    tasks.register<Exec>("stageWineXrBridge") {
+        enabled = hostCanRunXrPayloadScripts
+        dependsOn("buildModernXrNative")
+        val companion = providers.environmentVariable("GAMENATIVE_WINE_XR_BRIDGE")
+        doFirst {
+            check(companion.isPresent) { "GAMENATIVE_WINE_XR_BRIDGE must point to the ARM64X Wine builtin companion" }
+        }
+        commandLine(
+            "powershell",
+            "-ExecutionPolicy",
+            "Bypass",
+            "-File",
+            rootProject.file("tools/stage-wine-xr-bridge.ps1").absolutePath,
+            "-CompanionPath",
+            companion.getOrElse(""),
+        )
+    }
+
+    tasks.register<Exec>("stageOpenComposite") {
+        enabled = hostCanRunXrPayloadScripts
+        commandLine(
+            "powershell",
+            "-ExecutionPolicy",
+            "Bypass",
+            "-File",
+            rootProject.file("tools/stage-opencomposite.ps1").absolutePath,
+        )
+    }
+
+    tasks.register<Exec>("verifyModernXrPayload") {
+        enabled = hostCanRunXrPayloadScripts
+        dependsOn("buildModernXrNative", "buildWindowsXrRuntime", "stageWineXrBridge", "stageOpenComposite")
+        commandLine(
+            "powershell",
+            "-ExecutionPolicy",
+            "Bypass",
+            "-File",
+            rootProject.file("tools/verify-xr-payload.ps1").absolutePath,
+        )
+    }
+
+    tasks.register("prepareModernXrPayload") {
+        dependsOn("verifyModernXrPayload")
+    }
+
+
     // externalNativeBuild {
     //   cmake {
     //       path = file("src/main/cpp/asurfacerenderer/CMakeLists.txt")

app/src/legacyXr/AndroidManifest.xml

@@ -75,6 +75,9 @@
             <meta-data
                 android:name="com.oculus.vrshell.supports_free_resizing"
                 android:value="true" />
+            <meta-data
+                android:name="pvr.app.type"
+                android:value="vr" />
         </activity>
     </application>
 

app/src/legacyXr/assets/gamenative_xr_unixbridge.wine-commit

@@ -0,0 +1 @@
+77eed5501e077f5f0422d063b171a3a4491f52a6

app/src/legacyXr/assets/payload.version

@@ -0,0 +1 @@
+3 fb4792ecc21725bec26e3e1754af6c954b39e0f641192d257e578629dea9c92c eb77fcd88b7a93c1fd28e8aaa05b22d0d454a11ebf488743cb4008a058d93e8e

app/src/main/cpp/xrimmersive/CMakeLists.txt

@@ -17,6 +17,8 @@ project(xrimmersive)
 add_library(xrimmersive SHARED
     xr_immersive.cpp
     jni_bridge.cpp
+    xr_windows_projection.cpp
+    xr_windows_transport.cpp
 )
 
 find_package(OpenXR REQUIRED CONFIG)
@@ -30,4 +32,11 @@ target_link_libraries(xrimmersive
     log
 )
 
+target_compile_definitions(xrimmersive PRIVATE
+    XR_USE_PLATFORM_ANDROID=1
+    XR_USE_GRAPHICS_API_OPENGL_ES=1
+    EGL_EGLEXT_PROTOTYPES=1
+    GL_GLEXT_PROTOTYPES=1
+)
+
 target_compile_options(xrimmersive PRIVATE -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers)

app/src/main/cpp/xrimmersive/jni_bridge.cpp

@@ -3,6 +3,8 @@
 #include <android/hardware_buffer_jni.h>
 #include <android/log.h>
 
+#include <atomic>
+#include <condition_variable>
 #include <mutex>
 #include <unordered_set>
 
@@ -13,13 +15,18 @@ namespace {
 struct NativeHandle {
     xrimmersive::XrImmersiveSession *session;
     jobject activityGlobalRef;
+    std::atomic<int> waiters{0};
 };
 
 // Lock ordering: gHandleMutex is the outermost lock — it may be held while calling into
 // XrImmersiveSession (which takes its own inner mutexes), never the other way round, and it is
 // never held across XrImmersiveSession::join() or AndroidBitmap_lockPixels/unlockPixels. Every
-// entry point must hold it for the WHOLE call into the session, not just the lookup.
+// entry point must hold it for the WHOLE call into the session, not just the lookup. The one
+// exception is nativeWaitWindowsFrame, which pins the handle with NativeHandle::waiters instead so
+// the (up to 1 s) wait does not block every other entry point; nativeJoinAndDestroy waits for
+// waiters to drain before freeing the session.
 std::mutex gHandleMutex;
+std::condition_variable gHandleCondition;
 std::unordered_set<NativeHandle *> gLiveHandles;
 
 NativeHandle *LiveHandle(jlong handlePtr) {
@@ -68,8 +75,10 @@ Java_app_gamenative_ui_screen_xr_XrNative_nativeJoinAndDestroy(JNIEnv *env, jcla
     {
         // Retiring the handle under the lock means every in-flight caller has already left its
         // critical section, and no new one can enter, before anything is destroyed.
-        std::lock_guard<std::mutex> lock(gHandleMutex);
+        std::unique_lock<std::mutex> lock(gHandleMutex);
         if (gLiveHandles.erase(handle) == 0) return;
+        handle->session->requestStop();
+        gHandleCondition.wait(lock, [handle] { return handle->waiters.load() == 0; });
     }
     handle->session->join();
     delete handle->session;
@@ -127,6 +136,125 @@ Java_app_gamenative_ui_screen_xr_XrNative_nativePollSnapshot(JNIEnv *env, jclass
     return snapshot.quickMenuClicked ? JNI_TRUE : JNI_FALSE;
 }
 
+JNIEXPORT jboolean JNICALL
+Java_app_gamenative_ui_screen_xr_XrNative_nativeWaitWindowsFrame(
+    JNIEnv *env, jclass, jlong handlePtr, jlong afterSerial, jint timeoutMs,
+    jlongArray outTiming, jfloatArray outViews, jfloatArray outInput, jintArray outFlags) {
+    if (env->GetArrayLength(outTiming) < 12 || env->GetArrayLength(outViews) < 22 ||
+        env->GetArrayLength(outInput) < 36 || env->GetArrayLength(outFlags) < 3) return JNI_FALSE;
+    xrimmersive::WindowsRuntimeSnapshot snapshot;
+    xrimmersive::XrImmersiveSession *session = nullptr;
+    NativeHandle *handle = nullptr;
+    {
+        std::lock_guard<std::mutex> lock(gHandleMutex);
+        handle = LiveHandle(handlePtr);
+        if (handle == nullptr) return JNI_FALSE;
+        session = handle->session;
+        handle->waiters.fetch_add(1);
+    }
+    const bool got = session->waitWindowsRuntimeSnapshot(
+        static_cast<uint64_t>(afterSerial), static_cast<uint32_t>(timeoutMs), &snapshot);
+    {
+        std::lock_guard<std::mutex> lock(gHandleMutex);
+        handle->waiters.fetch_sub(1);
+    }
+    gHandleCondition.notify_all();
+    if (!got) return JNI_FALSE;
+    const jlong timing[12] = {
+        static_cast<jlong>(snapshot.frameSerial),
+        static_cast<jlong>(snapshot.predictedDisplayTime),
+        static_cast<jlong>(snapshot.predictedDisplayPeriod),
+        static_cast<jlong>(snapshot.sessionState),
+        static_cast<jlong>(snapshot.shouldRender ? 1 : 0),
+        static_cast<jlong>(snapshot.recommendedWidth),
+        static_cast<jlong>(snapshot.recommendedHeight),
+        static_cast<jlong>(snapshot.stageAvailable ? 1 : 0),
+        static_cast<jlong>(snapshot.stageBounds.width * 1000000.0f),
+        static_cast<jlong>(snapshot.stageBounds.height * 1000000.0f),
+        static_cast<jlong>(snapshot.stageSpaceActive ? 1 : 0),
+        static_cast<jlong>(snapshot.recenterSerial),
+    };
+    env->SetLongArrayRegion(outTiming, 0, 12, timing);
+    jfloat views[22]{};
+    for (size_t eye = 0; eye < 2; ++eye) {
+        const XrView &view = snapshot.views[eye];
+        const size_t base = eye * 11;
+        views[base] = view.pose.orientation.x;
+        views[base + 1] = view.pose.orientation.y;
+        views[base + 2] = view.pose.orientation.z;
+        views[base + 3] = view.pose.orientation.w;
+        views[base + 4] = view.pose.position.x;
+        views[base + 5] = view.pose.position.y;
+        views[base + 6] = view.pose.position.z;
+        views[base + 7] = view.fov.angleLeft;
+        views[base + 8] = view.fov.angleRight;
+        views[base + 9] = view.fov.angleUp;
+        views[base + 10] = view.fov.angleDown;
+    }
+    env->SetFloatArrayRegion(outViews, 0, 22, views);
+    const auto &input = snapshot.input;
+    jfloat inputValues[36]{};
+    for (size_t hand = 0; hand < 2; ++hand) {
+        const size_t base = hand * 18;
+        const XrPosef &grip = input.gripPoses[hand];
+        const XrPosef &aim = input.aimPoses[hand];
+        inputValues[base] = hand == 0 ? input.triggerL : input.triggerR;
+        inputValues[base + 1] = hand == 0 ? input.squeezeL : input.squeezeR;
+        inputValues[base + 2] = hand == 0 ? input.leftX : input.rightX;
+        inputValues[base + 3] = -(hand == 0 ? input.leftY : input.rightY);
+        inputValues[base + 4] = grip.orientation.x;
+        inputValues[base + 5] = grip.orientation.y;
+        inputValues[base + 6] = grip.orientation.z;
+        inputValues[base + 7] = grip.orientation.w;
+        inputValues[base + 8] = grip.position.x;
+        inputValues[base + 9] = grip.position.y;
+        inputValues[base + 10] = grip.position.z;
+        inputValues[base + 11] = aim.orientation.x;
+        inputValues[base + 12] = aim.orientation.y;
+        inputValues[base + 13] = aim.orientation.z;
+        inputValues[base + 14] = aim.orientation.w;
+        inputValues[base + 15] = aim.position.x;
+        inputValues[base + 16] = aim.position.y;
+        inputValues[base + 17] = aim.position.z;
+    }
+    env->SetFloatArrayRegion(outInput, 0, 36, inputValues);
+    const jint flags[3] = {
+        static_cast<jint>(snapshot.viewStateFlags),
+        static_cast<jint>(input.buttons),
+        static_cast<jint>((input.aimPoseValid[0] && input.gripPoseValid[0] ? 1 : 0) |
+                          (input.aimPoseValid[1] && input.gripPoseValid[1] ? 2 : 0)),
+    };
+    env->SetIntArrayRegion(outFlags, 0, 3, flags);
+    return JNI_TRUE;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_app_gamenative_ui_screen_xr_XrNative_nativeIsWindowsStereoActive(
+    JNIEnv *, jclass, jlong handlePtr) {
+    std::lock_guard<std::mutex> lock(gHandleMutex);
+    auto *handle = LiveHandle(handlePtr);
+    return handle != nullptr && handle->session->windowsStereoActive() ? JNI_TRUE : JNI_FALSE;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_app_gamenative_ui_screen_xr_XrNative_nativeApplyWindowsHaptic(
+    JNIEnv *, jclass, jlong handlePtr, jint hand, jfloat amplitude, jlong duration,
+    jfloat frequency) {
+    std::lock_guard<std::mutex> lock(gHandleMutex);
+    auto *handle = LiveHandle(handlePtr);
+    return handle != nullptr && handle->session->applyWindowsHaptic(
+        static_cast<uint32_t>(hand), amplitude, static_cast<XrDuration>(duration), frequency)
+        ? JNI_TRUE : JNI_FALSE;
+}
+
+JNIEXPORT void JNICALL
+Java_app_gamenative_ui_screen_xr_XrNative_nativeSetWindowsOverlayVisible(
+    JNIEnv *, jclass, jlong handlePtr, jboolean visible) {
+    std::lock_guard<std::mutex> lock(gHandleMutex);
+    auto *handle = LiveHandle(handlePtr);
+    if (handle != nullptr) handle->session->setWindowsOverlayVisible(visible == JNI_TRUE);
+}
+
 // Called from ImmersiveXrActivity's PixelCopy capture loop with the game's actual rendered
 // frame (ARGB_8888 bitmap). Copies the pixels into the session's pending-frame buffer; the
 // render thread uploads them to the GPU and draws them into the quad layer on its own.