From 789f2122c0cf1b475983a84b6c34fd070cc8a002 Mon Sep 17 00:00:00 2001 From: Florian Reintgen <85225228+TheReal-Flo@users.noreply.github.com> Date: Sat, 22 Aug 2026 10:58:03 +0200 Subject: [PATCH 01/46] Add Windows VR support --- app/build.gradle.kts | 71 +- app/src/main/cpp/xrimmersive/CMakeLists.txt | 9 + app/src/main/cpp/xrimmersive/jni_bridge.cpp | 110 + app/src/main/cpp/xrimmersive/xr_immersive.cpp | 250 +- app/src/main/cpp/xrimmersive/xr_immersive.h | 55 +- .../cpp/xrimmersive/xr_windows_projection.cpp | 470 +++ .../cpp/xrimmersive/xr_windows_projection.h | 61 + .../cpp/xrimmersive/xr_windows_transport.cpp | 609 +++ .../cpp/xrimmersive/xr_windows_transport.h | 119 + .../app/gamenative/ui/component/QuickMenu.kt | 33 +- .../ui/screen/xr/ImmersiveControls.kt | 7 + .../ui/screen/xr/ImmersiveSessionHooks.kt | 1 + .../ui/screen/xr/ImmersiveXrActivity.kt | 111 +- .../app/gamenative/ui/screen/xr/XrNative.kt | 22 + .../xr/windows/WindowsVrControlServer.kt | 250 ++ .../screen/xr/windows/WindowsVrDiagnostics.kt | 71 + .../windows/WindowsVrEmulationDiagnostics.kt | 75 + .../xr/windows/WindowsVrPayloadManager.kt | 329 ++ .../xr/windows/WindowsVrRuntimeConfig.kt | 22 + .../xr/windows/WindowsVrRuntimeService.kt | 190 + .../xr/windows/WindowsVrSnapshotProvider.kt | 56 + .../ui/screen/xserver/XServerScreen.kt | 11 +- .../com/winlator/renderer/GLRenderer.java | 21 +- .../com/winlator/renderer/VulkanRenderer.java | 28 +- .../java/com/winlator/xserver/XServer.java | 9 + .../xserver/extensions/PresentExtension.java | 7 + app/src/main/res/values/strings.xml | 6 + .../windows/openxr_runtime/CMakeLists.txt | 30 + .../openxr_runtime/builtin/Makefile.in | 4 + .../builtin/gamenative_xr_unixbridge.c | 29 + .../builtin/gamenative_xr_unixbridge.spec | 1 + .../builtin/gamenative_xr_unixbridge32.dll | Bin 0 -> 41706 bytes .../main/windows/openxr_runtime/dxgi_x64.def | 3 + .../main/windows/openxr_runtime/dxgi_x86.def | 3 + .../openxr_runtime/gamenative_actions.c | 332 ++ .../openxr_runtime/gamenative_actions.h | 31 + .../openxr_runtime/gamenative_control.c | 198 + .../openxr_runtime/gamenative_control.h | 42 + .../windows/openxr_runtime/gamenative_dxvk.c | 108 + .../windows/openxr_runtime/gamenative_dxvk.h | 17 + .../gamenative_openxr_runtime.c | 3360 +++++++++++++++++ .../gamenative_openxr_runtime_x64.def | 4 + .../gamenative_openxr_runtime_x86.def | 4 + .../openxr_runtime/gamenative_openxr_unix.h | 130 + .../gamenative_openxr_unix_abi.h | 114 + .../windows/openxr_runtime/kernel32_x64.def | 12 + .../windows/openxr_runtime/kernel32_x86.def | 12 + .../main/windows/openxr_runtime/ntdll_x64.def | 4 + .../main/windows/openxr_runtime/ntdll_x86.def | 4 + .../openxr_runtime/unix/CMakeLists.txt | 8 + .../unix/gamenative_openxr_unix.c | 1566 ++++++++ .../windows/openxr_runtime/ws2_32_x64.def | 10 + .../windows/openxr_runtime/ws2_32_x86.def | 10 + tools/build-windows-xr-runtime.ps1 | 60 + tools/build-wine-xr-bridge.sh | 3 + tools/build-xr-native.ps1 | 37 + tools/provision-build-arm64x-wine-bridge.sh | 121 + tools/stage-opencomposite.ps1 | 15 + tools/stage-wine-xr-bridge.ps1 | 15 + tools/verify-arm64x-wine-pair.ps1 | 115 + tools/verify-xr-payload.ps1 | 31 + 61 files changed, 9403 insertions(+), 33 deletions(-) create mode 100644 app/src/main/cpp/xrimmersive/xr_windows_projection.cpp create mode 100644 app/src/main/cpp/xrimmersive/xr_windows_projection.h create mode 100644 app/src/main/cpp/xrimmersive/xr_windows_transport.cpp create mode 100644 app/src/main/cpp/xrimmersive/xr_windows_transport.h create mode 100644 app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrControlServer.kt create mode 100644 app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrDiagnostics.kt create mode 100644 app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrEmulationDiagnostics.kt create mode 100644 app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrPayloadManager.kt create mode 100644 app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrRuntimeConfig.kt create mode 100644 app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrRuntimeService.kt create mode 100644 app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrSnapshotProvider.kt create mode 100644 app/src/main/windows/openxr_runtime/CMakeLists.txt create mode 100644 app/src/main/windows/openxr_runtime/builtin/Makefile.in create mode 100644 app/src/main/windows/openxr_runtime/builtin/gamenative_xr_unixbridge.c create mode 100644 app/src/main/windows/openxr_runtime/builtin/gamenative_xr_unixbridge.spec create mode 100644 app/src/main/windows/openxr_runtime/builtin/gamenative_xr_unixbridge32.dll create mode 100644 app/src/main/windows/openxr_runtime/dxgi_x64.def create mode 100644 app/src/main/windows/openxr_runtime/dxgi_x86.def create mode 100644 app/src/main/windows/openxr_runtime/gamenative_actions.c create mode 100644 app/src/main/windows/openxr_runtime/gamenative_actions.h create mode 100644 app/src/main/windows/openxr_runtime/gamenative_control.c create mode 100644 app/src/main/windows/openxr_runtime/gamenative_control.h create mode 100644 app/src/main/windows/openxr_runtime/gamenative_dxvk.c create mode 100644 app/src/main/windows/openxr_runtime/gamenative_dxvk.h create mode 100644 app/src/main/windows/openxr_runtime/gamenative_openxr_runtime.c create mode 100644 app/src/main/windows/openxr_runtime/gamenative_openxr_runtime_x64.def create mode 100644 app/src/main/windows/openxr_runtime/gamenative_openxr_runtime_x86.def create mode 100644 app/src/main/windows/openxr_runtime/gamenative_openxr_unix.h create mode 100644 app/src/main/windows/openxr_runtime/gamenative_openxr_unix_abi.h create mode 100644 app/src/main/windows/openxr_runtime/kernel32_x64.def create mode 100644 app/src/main/windows/openxr_runtime/kernel32_x86.def create mode 100644 app/src/main/windows/openxr_runtime/ntdll_x64.def create mode 100644 app/src/main/windows/openxr_runtime/ntdll_x86.def create mode 100644 app/src/main/windows/openxr_runtime/unix/CMakeLists.txt create mode 100644 app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c create mode 100644 app/src/main/windows/openxr_runtime/ws2_32_x64.def create mode 100644 app/src/main/windows/openxr_runtime/ws2_32_x86.def create mode 100644 tools/build-windows-xr-runtime.ps1 create mode 100644 tools/build-wine-xr-bridge.sh create mode 100644 tools/build-xr-native.ps1 create mode 100644 tools/provision-build-arm64x-wine-bridge.sh create mode 100644 tools/stage-opencomposite.ps1 create mode 100644 tools/stage-wine-xr-bridge.ps1 create mode 100644 tools/verify-arm64x-wine-pair.ps1 create mode 100644 tools/verify-xr-payload.ps1 diff --git a/app/build.gradle.kts b/app/build.gradle.kts index a76918c971..b5b6d6c450 100644 --- a/app/build.gradle.kts +++ b/app/build.gradle.kts @@ -268,10 +268,10 @@ android { } getByName("modernXr") { assets { - srcDirs("src/modern/assets", "src/main/assets") + srcDirs("src/modern/assets", "src/main/assets", "build/generated/xrPayload/modernXr") } jniLibs { - srcDirs("src/modern/jniLibs") + setSrcDirs(listOf("src/modern/jniLibs", "build/generated/xrNative/modernXr")) } } getByName("debug") { @@ -283,6 +283,73 @@ android { ignoreFormatFailures = false } + tasks.register("buildModernXrNative") { + commandLine( + "powershell", + "-ExecutionPolicy", + "Bypass", + "-File", + rootProject.file("tools/build-xr-native.ps1").absolutePath, + ) + } + + tasks.register("buildWindowsXrRuntime") { + commandLine( + "powershell", + "-ExecutionPolicy", + "Bypass", + "-File", + rootProject.file("tools/build-windows-xr-runtime.ps1").absolutePath, + ) + } + + tasks.register("stageWineXrBridge") { + 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("stageOpenComposite") { + commandLine( + "powershell", + "-ExecutionPolicy", + "Bypass", + "-File", + rootProject.file("tools/stage-opencomposite.ps1").absolutePath, + ) + } + + tasks.register("verifyModernXrPayload") { + dependsOn("buildModernXrNative", "buildWindowsXrRuntime", "stageWineXrBridge", "stageOpenComposite") + commandLine( + "powershell", + "-ExecutionPolicy", + "Bypass", + "-File", + rootProject.file("tools/verify-xr-payload.ps1").absolutePath, + ) + } + + tasks.register("prepareModernXrPayload") { + dependsOn("verifyModernXrPayload") + } + + tasks.matching { + it.name.startsWith("mergeModernXr") && it.name.endsWith("Assets") + }.configureEach { + dependsOn("prepareModernXrPayload") + } + // externalNativeBuild { // cmake { // path = file("src/main/cpp/asurfacerenderer/CMakeLists.txt") diff --git a/app/src/main/cpp/xrimmersive/CMakeLists.txt b/app/src/main/cpp/xrimmersive/CMakeLists.txt index ec6e3b0ea8..973e8399ac 100644 --- a/app/src/main/cpp/xrimmersive/CMakeLists.txt +++ b/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) diff --git a/app/src/main/cpp/xrimmersive/jni_bridge.cpp b/app/src/main/cpp/xrimmersive/jni_bridge.cpp index 4834fe5234..9e032a8b28 100644 --- a/app/src/main/cpp/xrimmersive/jni_bridge.cpp +++ b/app/src/main/cpp/xrimmersive/jni_bridge.cpp @@ -127,6 +127,116 @@ 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) < 11 || env->GetArrayLength(outViews) < 22 || + env->GetArrayLength(outInput) < 36 || env->GetArrayLength(outFlags) < 3) return JNI_FALSE; + xrimmersive::WindowsRuntimeSnapshot snapshot; + { + std::lock_guard lock(gHandleMutex); + auto *handle = LiveHandle(handlePtr); + if (handle == nullptr) return JNI_FALSE; + if (!handle->session->waitWindowsRuntimeSnapshot( + static_cast(afterSerial), static_cast(timeoutMs), &snapshot)) { + return JNI_FALSE; + } + } + const jlong timing[11] = { + static_cast(snapshot.frameSerial), + static_cast(snapshot.predictedDisplayTime), + static_cast(snapshot.predictedDisplayPeriod), + static_cast(snapshot.sessionState), + static_cast(snapshot.shouldRender ? 1 : 0), + static_cast(snapshot.recommendedWidth), + static_cast(snapshot.recommendedHeight), + static_cast(snapshot.stageAvailable ? 1 : 0), + static_cast(snapshot.stageBounds.width * 1000000.0f), + static_cast(snapshot.stageBounds.height * 1000000.0f), + static_cast(snapshot.stageSpaceActive ? 1 : 0), + }; + env->SetLongArrayRegion(outTiming, 0, 11, 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(snapshot.viewStateFlags), + static_cast(input.buttons), + static_cast((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 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 lock(gHandleMutex); + auto *handle = LiveHandle(handlePtr); + return handle != nullptr && handle->session->applyWindowsHaptic( + static_cast(hand), amplitude, static_cast(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 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. diff --git a/app/src/main/cpp/xrimmersive/xr_immersive.cpp b/app/src/main/cpp/xrimmersive/xr_immersive.cpp index 0489704b5a..08543c9191 100644 --- a/app/src/main/cpp/xrimmersive/xr_immersive.cpp +++ b/app/src/main/cpp/xrimmersive/xr_immersive.cpp @@ -60,6 +60,7 @@ bool XrImmersiveSession::initialize(JavaVM *vm, jobject activityRef) { void XrImmersiveSession::requestStop() { stopRequested_.store(true); + windowsSnapshotCondition_.notify_all(); } void XrImmersiveSession::join() { @@ -77,6 +78,40 @@ InputSnapshot XrImmersiveSession::pollSnapshot() { return result; } +bool XrImmersiveSession::waitWindowsRuntimeSnapshot(uint64_t afterSerial, uint32_t timeoutMs, + WindowsRuntimeSnapshot *snapshot) { + if (snapshot == nullptr) return false; + std::unique_lock lock(windowsSnapshotMutex_); + windowsSnapshotCondition_.wait_for( + lock, std::chrono::milliseconds(timeoutMs), + [this, afterSerial] { return windowsSnapshot_.frameSerial > afterSerial || stopRequested_.load(); }); + if (windowsSnapshot_.frameSerial <= afterSerial) return false; + *snapshot = windowsSnapshot_; + return true; +} + +bool XrImmersiveSession::windowsStereoActive() const { + return stereoActive_.load(); +} + +bool XrImmersiveSession::applyWindowsHaptic(uint32_t hand, float amplitude, XrDuration duration, + float frequency) { + if (hand > 1 || session_ == XR_NULL_HANDLE || hapticAction_ == XR_NULL_HANDLE) return false; + XrHapticActionInfo actionInfo{XR_TYPE_HAPTIC_ACTION_INFO}; + actionInfo.action = hapticAction_; + actionInfo.subactionPath = handPaths_[hand]; + XrHapticVibration vibration{XR_TYPE_HAPTIC_VIBRATION}; + vibration.amplitude = std::clamp(amplitude, 0.0f, 1.0f); + vibration.duration = duration; + vibration.frequency = frequency; + return XR_SUCCEEDED(xrApplyHapticFeedback( + session_, &actionInfo, reinterpret_cast(&vibration))); +} + +void XrImmersiveSession::setWindowsOverlayVisible(bool visible) { + windowsOverlayVisible_.store(visible); +} + void XrImmersiveSession::submitFrame(const uint8_t *rgbaPixels, int32_t width, int32_t height, int32_t strideBytes) { if (width <= 0 || height <= 0) return; @@ -212,10 +247,44 @@ void XrImmersiveSession::runLoop() { applyPendingPassthroughState(); syncControllerInputs(frameState.predictedDisplayTime); + WindowsRuntimeSnapshot runtimeSnapshot; + { + std::lock_guard lock(windowsSnapshotMutex_); + runtimeSnapshot = windowsSnapshot_; + } + runtimeSnapshot.frameSerial += 1; + runtimeSnapshot.predictedDisplayTime = frameState.predictedDisplayTime; + runtimeSnapshot.predictedDisplayPeriod = frameState.predictedDisplayPeriod; + runtimeSnapshot.sessionState = sessionState_; + runtimeSnapshot.shouldRender = frameState.shouldRender == XR_TRUE; + XrViewLocateInfo viewLocateInfo{XR_TYPE_VIEW_LOCATE_INFO}; + viewLocateInfo.viewConfigurationType = XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO; + viewLocateInfo.displayTime = frameState.predictedDisplayTime; + viewLocateInfo.space = windowsTrackingSpace_; + XrViewState viewState{XR_TYPE_VIEW_STATE}; + uint32_t viewCount = 0; + if (XR_SUCCEEDED(xrLocateViews(session_, &viewLocateInfo, &viewState, 2, &viewCount, + runtimeSnapshot.views.data())) && viewCount == 2) { + runtimeSnapshot.viewStateFlags = viewState.viewStateFlags; + } else { + runtimeSnapshot.viewStateFlags = 0; + } + { + std::lock_guard lock(snapshotMutex_); + runtimeSnapshot.input = snapshot_; + } + syncWindowsTrackingPoses(&runtimeSnapshot.input, frameState.predictedDisplayTime); + { + std::lock_guard lock(windowsSnapshotMutex_); + windowsSnapshot_ = runtimeSnapshot; + } + windowsSnapshotCondition_.notify_all(); + // Every xrBeginFrame must be matched by an xrEndFrame, but a layer may only reference a // swapchain image that was actually acquired — so a failed renderFrame() still ends the // frame, just with no layers. - if (frameState.shouldRender && renderFrame()) { + if (frameState.shouldRender && submitWindowsProjection(frameState.predictedDisplayTime)) { + } else if (frameState.shouldRender && renderFrame()) { submitQuadLayer(frameState.predictedDisplayTime, localSpace_, swapchain_, swapchainWidth_, swapchainHeight_, true); } else { @@ -429,6 +498,17 @@ bool XrImmersiveSession::setupInstanceAndSession() { "xrCreateReferenceSpace")) { return false; } + windowsTrackingSpace_ = localSpace_; + spaceCreateInfo.referenceSpaceType = XR_REFERENCE_SPACE_TYPE_STAGE; + const XrResult stageSpaceResult = xrCreateReferenceSpace(session_, &spaceCreateInfo, &stageSpace_); + if (stageSpaceResult == XR_SUCCESS && stageSpace_ != XR_NULL_HANDLE) { + windowsTrackingSpace_ = stageSpace_; + LOGI("Windows VR tracking space: STAGE"); + } else { + stageSpace_ = XR_NULL_HANDLE; + LOGI("Windows VR tracking space: LOCAL fallback (xrCreateReferenceSpace STAGE=%d)", + static_cast(stageSpaceResult)); + } uint32_t formatCount = 0; xrEnumerateSwapchainFormats(session_, 0, &formatCount, nullptr); @@ -477,6 +557,41 @@ bool XrImmersiveSession::setupInstanceAndSession() { glGenFramebuffers(1, &framebuffer_); + uint32_t projectionViewCount = 0; + xrEnumerateViewConfigurationViews(instance_, systemId_, XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO, + 0, &projectionViewCount, nullptr); + std::vector projectionViews( + projectionViewCount, {XR_TYPE_VIEW_CONFIGURATION_VIEW}); + if (projectionViewCount >= 2 && XR_SUCCEEDED(xrEnumerateViewConfigurationViews( + instance_, systemId_, XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO, + projectionViewCount, &projectionViewCount, projectionViews.data()))) { + { + std::lock_guard lock(windowsSnapshotMutex_); + windowsSnapshot_.recommendedWidth = projectionViews[0].recommendedImageRectWidth; + windowsSnapshot_.recommendedHeight = projectionViews[0].recommendedImageRectHeight; + const XrResult boundsResult = xrGetReferenceSpaceBoundsRect( + session_, XR_REFERENCE_SPACE_TYPE_STAGE, &windowsSnapshot_.stageBounds); + windowsSnapshot_.stageSpaceActive = stageSpace_ != XR_NULL_HANDLE; + windowsSnapshot_.stageAvailable = stageSpace_ != XR_NULL_HANDLE && + boundsResult == XR_SUCCESS && + windowsSnapshot_.stageBounds.width > 0.0f && + windowsSnapshot_.stageBounds.height > 0.0f; + if (!windowsSnapshot_.stageAvailable) windowsSnapshot_.stageBounds = {0.0f, 0.0f}; + LOGI("Windows VR stage: active=%d bounds=%d %.3fx%.3f result=%d", + windowsSnapshot_.stageSpaceActive ? 1 : 0, + windowsSnapshot_.stageAvailable ? 1 : 0, + windowsSnapshot_.stageBounds.width, + windowsSnapshot_.stageBounds.height, + static_cast(boundsResult)); + } + windowsProjectionReady_ = windowsProjection_.initialize( + session_, chosenFormat, + projectionViews[0].recommendedImageRectWidth, + projectionViews[0].recommendedImageRectHeight, + eglDisplay_); + } + windowsTransport_.start("@gamenative-xr"); + // --- Input: action set + Meta Quest Touch controller bindings. --- XrActionSetCreateInfo actionSetInfo{XR_TYPE_ACTION_SET_CREATE_INFO}; std::strncpy(actionSetInfo.actionSetName, "gameplay", XR_MAX_ACTION_SET_NAME_SIZE - 1); @@ -510,6 +625,8 @@ bool XrImmersiveSession::setupInstanceAndSession() { createAction("menu_left", XR_ACTION_TYPE_BOOLEAN_INPUT, &menuLAction_); createAction("aim_pose_left", XR_ACTION_TYPE_POSE_INPUT, &aimPoseLeftAction_); createAction("aim_pose_right", XR_ACTION_TYPE_POSE_INPUT, &aimPoseRightAction_); + createAction("grip_pose_left", XR_ACTION_TYPE_POSE_INPUT, &gripPoseLeftAction_); + createAction("grip_pose_right", XR_ACTION_TYPE_POSE_INPUT, &gripPoseRightAction_); auto path = [this](const char *p) { XrPath result = XR_NULL_PATH; @@ -517,6 +634,16 @@ bool XrImmersiveSession::setupInstanceAndSession() { return result; }; + handPaths_[0] = path("/user/hand/left"); + handPaths_[1] = path("/user/hand/right"); + XrActionCreateInfo hapticInfo{XR_TYPE_ACTION_CREATE_INFO}; + std::strncpy(hapticInfo.actionName, "haptic", XR_MAX_ACTION_NAME_SIZE - 1); + std::strncpy(hapticInfo.localizedActionName, "Haptic", XR_MAX_LOCALIZED_ACTION_NAME_SIZE - 1); + hapticInfo.actionType = XR_ACTION_TYPE_VIBRATION_OUTPUT; + hapticInfo.countSubactionPaths = 2; + hapticInfo.subactionPaths = handPaths_; + XrCheck(xrCreateAction(actionSet_, &hapticInfo, &hapticAction_), "haptic"); + std::vector bindings = { {buttonXAction_, path("/user/hand/left/input/x/click")}, {buttonYAction_, path("/user/hand/left/input/y/click")}, @@ -533,6 +660,10 @@ bool XrImmersiveSession::setupInstanceAndSession() { {menuLAction_, path("/user/hand/left/input/menu/click")}, {aimPoseLeftAction_, path("/user/hand/left/input/aim/pose")}, {aimPoseRightAction_, path("/user/hand/right/input/aim/pose")}, + {gripPoseLeftAction_, path("/user/hand/left/input/grip/pose")}, + {gripPoseRightAction_, path("/user/hand/right/input/grip/pose")}, + {hapticAction_, path("/user/hand/left/output/haptic")}, + {hapticAction_, path("/user/hand/right/output/haptic")}, }; XrInteractionProfileSuggestedBinding suggestedBinding{XR_TYPE_INTERACTION_PROFILE_SUGGESTED_BINDING}; @@ -553,6 +684,10 @@ bool XrImmersiveSession::setupInstanceAndSession() { XrCheck(xrCreateActionSpace(session_, &aimSpaceInfo, &aimSpaceLeft_), "xrCreateActionSpace(left aim)"); aimSpaceInfo.action = aimPoseRightAction_; XrCheck(xrCreateActionSpace(session_, &aimSpaceInfo, &aimSpaceRight_), "xrCreateActionSpace(right aim)"); + aimSpaceInfo.action = gripPoseLeftAction_; + XrCheck(xrCreateActionSpace(session_, &aimSpaceInfo, &gripSpaceLeft_), "xrCreateActionSpace(left grip)"); + aimSpaceInfo.action = gripPoseRightAction_; + XrCheck(xrCreateActionSpace(session_, &aimSpaceInfo, &gripSpaceRight_), "xrCreateActionSpace(right grip)"); if (passthroughExtensionAvailable_) { setupPassthrough(); @@ -854,6 +989,59 @@ bool XrImmersiveSession::renderFrame() { return true; } +bool XrImmersiveSession::submitWindowsProjection(XrTime predictedDisplayTime) { + if (!windowsProjectionReady_ || !windowsTransport_.hasStereoContent()) { + stereoActive_.store(false); + stereoMisses_ = 0; + return false; + } + XrCompositionLayerProjection projection{XR_TYPE_COMPOSITION_LAYER_PROJECTION}; + if (!windowsProjection_.render(windowsTransport_, windowsTrackingSpace_, &projection)) { + if (++stereoMisses_ >= 8) stereoActive_.store(false); + return false; + } + stereoMisses_ = 0; + stereoActive_.store(true); + XrCompositionLayerQuad overlay{XR_TYPE_COMPOSITION_LAYER_QUAD}; + const bool overlayRendered = windowsOverlayVisible_.load() && renderFrame(); + if (overlayRendered) { + overlay.layerFlags = XR_COMPOSITION_LAYER_BLEND_TEXTURE_SOURCE_ALPHA_BIT; + overlay.space = localSpace_; + overlay.eyeVisibility = XR_EYE_VISIBILITY_BOTH; + overlay.subImage.swapchain = swapchain_; + overlay.subImage.imageRect = {{0, 0}, {swapchainWidth_, swapchainHeight_}}; + const float distance = -quadPosZ_.load(); + const float yaw = distance > 0.0001f ? std::atan2(quadPosX_.load(), distance) : 0.0f; + const float pitch = distance > 0.0001f ? std::atan2(quadPosY_.load(), distance) : 0.0f; + const float cy = std::cos(yaw * 0.5f); + const float sy = std::sin(yaw * 0.5f); + const float cx = std::cos(pitch * 0.5f); + const float sx = std::sin(pitch * 0.5f); + overlay.pose = IdentityPose(); + overlay.pose.orientation = {cy * sx, -sy * cx, sy * sx, cy * cx}; + overlay.pose.position = {distance * std::sin(yaw) * std::cos(pitch), distance * std::sin(pitch), + -distance * std::cos(yaw) * std::cos(pitch)}; + overlay.size = {quadWidth_.load(), quadHeight_.load()}; + } + XrCompositionLayerPassthroughFB passthroughLayer{XR_TYPE_COMPOSITION_LAYER_PASSTHROUGH_FB}; + passthroughLayer.space = XR_NULL_HANDLE; + passthroughLayer.layerHandle = passthroughLayer_; + std::array layers{}; + uint32_t layerCount = 0; + if (passthroughActive_ && passthroughLayer_ != XR_NULL_HANDLE) { + layers[layerCount++] = reinterpret_cast(&passthroughLayer); + } + layers[layerCount++] = reinterpret_cast(&projection); + if (overlayRendered) layers[layerCount++] = reinterpret_cast(&overlay); + XrFrameEndInfo endInfo{XR_TYPE_FRAME_END_INFO}; + endInfo.displayTime = predictedDisplayTime; + endInfo.environmentBlendMode = passthroughActive_ ? XR_ENVIRONMENT_BLEND_MODE_ALPHA_BLEND + : XR_ENVIRONMENT_BLEND_MODE_OPAQUE; + endInfo.layerCount = layerCount; + endInfo.layers = layers.data(); + return XrCheck(xrEndFrame(session_, &endInfo), "xrEndFrame(windows projection)"); +} + void XrImmersiveSession::submitQuadLayer(XrTime predictedDisplayTime, XrSpace space, XrSwapchain swapchain, int32_t width, int32_t height, bool sessionActive) { @@ -1078,8 +1266,10 @@ void XrImmersiveSession::syncControllerInputs(XrTime predictedDisplayTime) { if (getBool(buttonYAction_)) next.buttons |= (1u << BUTTON_Y); if (getBool(buttonAAction_)) next.buttons |= (1u << BUTTON_A); if (getBool(buttonBAction_)) next.buttons |= (1u << BUTTON_B); - if (getFloat(squeezeLAction_) > 0.5f) next.buttons |= (1u << BUTTON_LB); - if (getFloat(squeezeRAction_) > 0.5f) next.buttons |= (1u << BUTTON_RB); + next.squeezeL = getFloat(squeezeLAction_); + next.squeezeR = getFloat(squeezeRAction_); + if (next.squeezeL > 0.5f) next.buttons |= (1u << BUTTON_LB); + if (next.squeezeR > 0.5f) next.buttons |= (1u << BUTTON_RB); // Menu/Start button: a short press still forwards a normal Start press to the game (for // the game's own pause/settings menu); holding it for 600ms instead opens the immersive @@ -1192,7 +1382,10 @@ void XrImmersiveSession::syncControllerInputs(XrTime predictedDisplayTime) { XrCheck(xrLocateSpace(aimSpaceRight_, localSpace_, predictedDisplayTime, &rightLoc), "xrLocateSpace(right)") && (rightLoc.locationFlags & kPoseValidBits) == kPoseValidBits; next.handPosesValid = haveLeft && haveRight; + next.aimPoseValid[0] = haveLeft; + next.aimPoseValid[1] = haveRight; if (haveLeft) { + next.aimPoses[0] = leftLoc.pose; next.leftHandPosX = leftLoc.pose.position.x; next.leftHandPosY = leftLoc.pose.position.y; next.leftHandPosZ = leftLoc.pose.position.z; @@ -1202,6 +1395,7 @@ void XrImmersiveSession::syncControllerInputs(XrTime predictedDisplayTime) { next.leftHandFwdZ = fwd[2]; } if (haveRight) { + next.aimPoses[1] = rightLoc.pose; next.rightHandPosX = rightLoc.pose.position.x; next.rightHandPosY = rightLoc.pose.position.y; next.rightHandPosZ = rightLoc.pose.position.z; @@ -1210,6 +1404,16 @@ void XrImmersiveSession::syncControllerInputs(XrTime predictedDisplayTime) { next.rightHandFwdY = fwd[1]; next.rightHandFwdZ = fwd[2]; } + XrSpaceLocation leftGrip{XR_TYPE_SPACE_LOCATION}; + XrSpaceLocation rightGrip{XR_TYPE_SPACE_LOCATION}; + next.gripPoseValid[0] = gripSpaceLeft_ != XR_NULL_HANDLE && + XrCheck(xrLocateSpace(gripSpaceLeft_, localSpace_, predictedDisplayTime, &leftGrip), "xrLocateSpace(left grip)") && + (leftGrip.locationFlags & kPoseValidBits) == kPoseValidBits; + next.gripPoseValid[1] = gripSpaceRight_ != XR_NULL_HANDLE && + XrCheck(xrLocateSpace(gripSpaceRight_, localSpace_, predictedDisplayTime, &rightGrip), "xrLocateSpace(right grip)") && + (rightGrip.locationFlags & kPoseValidBits) == kPoseValidBits; + if (next.gripPoseValid[0]) next.gripPoses[0] = leftGrip.pose; + if (next.gripPoseValid[1]) next.gripPoses[1] = rightGrip.pose; // Rate-limited raw-value dump (~every 0.5s at 90Hz) — temporary, for diagnosing controller // mapping reports; safe to remove once the analog stick mapping is confirmed solid. @@ -1225,7 +1429,34 @@ void XrImmersiveSession::syncControllerInputs(XrTime predictedDisplayTime) { snapshot_ = next; } +void XrImmersiveSession::syncWindowsTrackingPoses(InputSnapshot *snapshot, + XrTime predictedDisplayTime) { + if (snapshot == nullptr || windowsTrackingSpace_ == XR_NULL_HANDLE || + windowsTrackingSpace_ == localSpace_) return; + constexpr XrSpaceLocationFlags validBits = + XR_SPACE_LOCATION_POSITION_VALID_BIT | XR_SPACE_LOCATION_ORIENTATION_VALID_BIT; + XrSpaceLocation aim[2]{{XR_TYPE_SPACE_LOCATION}, {XR_TYPE_SPACE_LOCATION}}; + XrSpaceLocation grip[2]{{XR_TYPE_SPACE_LOCATION}, {XR_TYPE_SPACE_LOCATION}}; + const XrSpace aimSpaces[2]{aimSpaceLeft_, aimSpaceRight_}; + const XrSpace gripSpaces[2]{gripSpaceLeft_, gripSpaceRight_}; + for (uint32_t hand = 0; hand < 2; ++hand) { + snapshot->aimPoseValid[hand] = aimSpaces[hand] != XR_NULL_HANDLE && + XR_SUCCEEDED(xrLocateSpace(aimSpaces[hand], windowsTrackingSpace_, + predictedDisplayTime, &aim[hand])) && + (aim[hand].locationFlags & validBits) == validBits; + snapshot->gripPoseValid[hand] = gripSpaces[hand] != XR_NULL_HANDLE && + XR_SUCCEEDED(xrLocateSpace(gripSpaces[hand], windowsTrackingSpace_, + predictedDisplayTime, &grip[hand])) && + (grip[hand].locationFlags & validBits) == validBits; + if (snapshot->aimPoseValid[hand]) snapshot->aimPoses[hand] = aim[hand].pose; + if (snapshot->gripPoseValid[hand]) snapshot->gripPoses[hand] = grip[hand].pose; + } + snapshot->handPosesValid = snapshot->aimPoseValid[0] && snapshot->aimPoseValid[1]; +} + void XrImmersiveSession::teardown() { + windowsTransport_.stop(); + windowsProjection_.shutdown(); teardownPassthrough(); if (gameTexture_ != 0) { glDeleteTextures(1, &gameTexture_); @@ -1270,6 +1501,11 @@ void XrImmersiveSession::teardown() { xrDestroySpace(localSpace_); localSpace_ = XR_NULL_HANDLE; } + if (stageSpace_ != XR_NULL_HANDLE) { + xrDestroySpace(stageSpace_); + stageSpace_ = XR_NULL_HANDLE; + } + windowsTrackingSpace_ = XR_NULL_HANDLE; if (aimSpaceLeft_ != XR_NULL_HANDLE) { xrDestroySpace(aimSpaceLeft_); aimSpaceLeft_ = XR_NULL_HANDLE; @@ -1278,6 +1514,14 @@ void XrImmersiveSession::teardown() { xrDestroySpace(aimSpaceRight_); aimSpaceRight_ = XR_NULL_HANDLE; } + if (gripSpaceLeft_ != XR_NULL_HANDLE) { + xrDestroySpace(gripSpaceLeft_); + gripSpaceLeft_ = XR_NULL_HANDLE; + } + if (gripSpaceRight_ != XR_NULL_HANDLE) { + xrDestroySpace(gripSpaceRight_); + gripSpaceRight_ = XR_NULL_HANDLE; + } if (actionSet_ != XR_NULL_HANDLE) { xrDestroyActionSet(actionSet_); actionSet_ = XR_NULL_HANDLE; diff --git a/app/src/main/cpp/xrimmersive/xr_immersive.h b/app/src/main/cpp/xrimmersive/xr_immersive.h index c7240a0224..0161af2d2d 100644 --- a/app/src/main/cpp/xrimmersive/xr_immersive.h +++ b/app/src/main/cpp/xrimmersive/xr_immersive.h @@ -2,22 +2,23 @@ #include #include +#include #include +#include #include #include #include #include -#define EGL_EGLEXT_PROTOTYPES #include #include -#define GL_GLEXT_PROTOTYPES #include #include #include -#define XR_USE_PLATFORM_ANDROID 1 -#define XR_USE_GRAPHICS_API_OPENGL_ES 1 +#include "xr_windows_projection.h" +#include "xr_windows_transport.h" + #include #include @@ -50,6 +51,8 @@ struct InputSnapshot { float rightY = 0.0f; float triggerL = 0.0f; float triggerR = 0.0f; + float squeezeL = 0.0f; + float squeezeR = 0.0f; // Rising-edge only: holding the Touch controllers' Menu button for 600ms summons // GameNative's own quick menu. A short press of the same button is still forwarded as a // normal gamepad Start press (games use it for their own pause/settings menu). @@ -73,6 +76,26 @@ struct InputSnapshot { float leftHandFwdX = 0.0f, leftHandFwdY = 0.0f, leftHandFwdZ = -1.0f; float rightHandPosX = 0.0f, rightHandPosY = 0.0f, rightHandPosZ = 0.0f; float rightHandFwdX = 0.0f, rightHandFwdY = 0.0f, rightHandFwdZ = -1.0f; + XrPosef aimPoses[2]{{{0, 0, 0, 1}, {0, 0, 0}}, {{0, 0, 0, 1}, {0, 0, 0}}}; + XrPosef gripPoses[2]{{{0, 0, 0, 1}, {0, 0, 0}}, {{0, 0, 0, 1}, {0, 0, 0}}}; + bool aimPoseValid[2]{false, false}; + bool gripPoseValid[2]{false, false}; +}; + +struct WindowsRuntimeSnapshot { + uint64_t frameSerial = 0; + XrTime predictedDisplayTime = 0; + XrDuration predictedDisplayPeriod = 0; + XrSessionState sessionState = XR_SESSION_STATE_UNKNOWN; + bool shouldRender = false; + XrViewStateFlags viewStateFlags = 0; + uint32_t recommendedWidth = 0; + uint32_t recommendedHeight = 0; + bool stageAvailable = false; + bool stageSpaceActive = false; + XrExtent2Df stageBounds{0.0f, 0.0f}; + std::array views{{{XR_TYPE_VIEW}, {XR_TYPE_VIEW}}}; + InputSnapshot input; }; // Owns the OpenXR instance/session and its dedicated frame-loop thread. @@ -84,6 +107,11 @@ class XrImmersiveSession { void join(); InputSnapshot pollSnapshot(); + bool waitWindowsRuntimeSnapshot(uint64_t afterSerial, uint32_t timeoutMs, + WindowsRuntimeSnapshot *snapshot); + bool windowsStereoActive() const; + bool applyWindowsHaptic(uint32_t hand, float amplitude, XrDuration duration, float frequency); + void setWindowsOverlayVisible(bool visible); // Called from the JNI bridge with a freshly PixelCopy'd RGBA_8888 frame of the game's // actual rendered output (see ImmersiveXrActivity's capture loop). Copies into a @@ -125,8 +153,10 @@ class XrImmersiveSession { // caller must NOT submit a layer referencing it. bool renderFrame(); void syncControllerInputs(XrTime predictedDisplayTime); + void syncWindowsTrackingPoses(InputSnapshot *snapshot, XrTime predictedDisplayTime); void submitQuadLayer(XrTime predictedDisplayTime, XrSpace space, XrSwapchain swapchain, int32_t width, int32_t height, bool sessionActive); + bool submitWindowsProjection(XrTime predictedDisplayTime); void ensureQuadGeometryAndShader(); void uploadPendingGameFrameLocked(); void setupPassthrough(); @@ -140,9 +170,17 @@ class XrImmersiveSession { XrSystemId systemId_ = XR_NULL_SYSTEM_ID; XrSession session_ = XR_NULL_HANDLE; XrSpace localSpace_ = XR_NULL_HANDLE; + XrSpace stageSpace_ = XR_NULL_HANDLE; + XrSpace windowsTrackingSpace_ = XR_NULL_HANDLE; XrSwapchain swapchain_ = XR_NULL_HANDLE; XrSessionState sessionState_ = XR_SESSION_STATE_UNKNOWN; bool sessionRunning_ = false; + windowsvr::WindowsFrameTransport windowsTransport_; + windowsvr::WindowsProjectionPresenter windowsProjection_; + bool windowsProjectionReady_ = false; + std::atomic stereoActive_{false}; + std::atomic windowsOverlayVisible_{false}; + uint32_t stereoMisses_ = 0; // The quad swapchain follows the container's screen size (min width 1280) and the // refresh rate is per-container, both set through configure() before the session starts. @@ -224,8 +262,14 @@ class XrImmersiveSession { // InputSnapshot::pointerModeToggled. XrAction aimPoseLeftAction_ = XR_NULL_HANDLE; XrAction aimPoseRightAction_ = XR_NULL_HANDLE; + XrAction gripPoseLeftAction_ = XR_NULL_HANDLE; + XrAction gripPoseRightAction_ = XR_NULL_HANDLE; + XrAction hapticAction_ = XR_NULL_HANDLE; + XrPath handPaths_[2]{XR_NULL_PATH, XR_NULL_PATH}; XrSpace aimSpaceLeft_ = XR_NULL_HANDLE; XrSpace aimSpaceRight_ = XR_NULL_HANDLE; + XrSpace gripSpaceLeft_ = XR_NULL_HANDLE; + XrSpace gripSpaceRight_ = XR_NULL_HANDLE; bool lastL3Pressed_ = false; std::chrono::steady_clock::time_point lastL3ClickTime_; int l3ClickCount_ = 0; @@ -251,6 +295,9 @@ class XrImmersiveSession { std::mutex snapshotMutex_; InputSnapshot snapshot_; + std::mutex windowsSnapshotMutex_; + std::condition_variable windowsSnapshotCondition_; + WindowsRuntimeSnapshot windowsSnapshot_; // Quad transform — defaults match the original hardcoded values (2m in front, 16:9, // 1.6m wide). Atomics: written from Kotlin/JNI callers, read from the render thread. diff --git a/app/src/main/cpp/xrimmersive/xr_windows_projection.cpp b/app/src/main/cpp/xrimmersive/xr_windows_projection.cpp new file mode 100644 index 0000000000..7145f97833 --- /dev/null +++ b/app/src/main/cpp/xrimmersive/xr_windows_projection.cpp @@ -0,0 +1,470 @@ +#include "xr_windows_projection.h" + +#include +#include +#include +#include +#include +#include +#include + +namespace xrimmersive::windowsvr { + +namespace { + +constexpr uint32_t kDrmFormatAbgr8888 = + static_cast('A') | (static_cast('B') << 8) | + (static_cast('2') << 16) | (static_cast('4') << 24); +constexpr uint32_t kDrmFormatArgb8888 = + static_cast('A') | (static_cast('R') << 8) | + (static_cast('2') << 16) | (static_cast('4') << 24); + +struct DmaBufSync { + uint64_t flags; +}; + +constexpr uint64_t kDmaBufSyncRead = 1u << 0; +constexpr uint64_t kDmaBufSyncEnd = 1u << 2; + +#ifndef DMA_BUF_IOCTL_SYNC +#define DMA_BUF_IOCTL_SYNC _IOW('b', 0, DmaBufSync) +#endif + +GLuint compileShader(GLenum type, const char *source) { + const GLuint shader = glCreateShader(type); + glShaderSource(shader, 1, &source, nullptr); + glCompileShader(shader); + GLint compiled = GL_FALSE; + glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled); + if (compiled != GL_TRUE) { + glDeleteShader(shader); + return 0; + } + return shader; +} + +} + +bool WindowsProjectionPresenter::initialize(XrSession session, int64_t format, uint32_t width, + uint32_t height, EGLDisplay display) { + session_ = session; + width_ = width; + height_ = height; + display_ = display; + for (auto &eye : eglImages_) eye.fill(EGL_NO_IMAGE_KHR); + XrSwapchainCreateInfo info{XR_TYPE_SWAPCHAIN_CREATE_INFO}; + info.usageFlags = XR_SWAPCHAIN_USAGE_COLOR_ATTACHMENT_BIT | XR_SWAPCHAIN_USAGE_SAMPLED_BIT; + info.format = format; + info.sampleCount = 1; + info.width = width; + info.height = height; + info.faceCount = 1; + info.arraySize = 2; + info.mipCount = 1; + if (XR_FAILED(xrCreateSwapchain(session, &info, &swapchain_))) return false; + uint32_t count = 0; + if (XR_FAILED(xrEnumerateSwapchainImages(swapchain_, 0, &count, nullptr)) || count == 0) return false; + images_.assign(count, {XR_TYPE_SWAPCHAIN_IMAGE_OPENGL_ES_KHR}); + if (XR_FAILED(xrEnumerateSwapchainImages( + swapchain_, count, &count, + reinterpret_cast(images_.data())))) return false; + glGenFramebuffers(1, &framebuffer_); + return ensureProgram(); +} + +bool WindowsProjectionPresenter::ensureProgram() { + static const char *vertexSource = + "#version 300 es\nlayout(location=0) in vec2 p;layout(location=1) in vec2 t;" + "out vec2 uv;uniform vec4 u;void main(){uv=u.xy+t*u.zw;gl_Position=vec4(p,0,1);}"; + static const char *fragmentSource = + "#version 300 es\nprecision mediump float;in vec2 uv;uniform sampler2D s;" + "out vec4 c;void main(){c=texture(s,uv);}"; + const GLuint vertex = compileShader(GL_VERTEX_SHADER, vertexSource); + const GLuint fragment = compileShader(GL_FRAGMENT_SHADER, fragmentSource); + if (vertex == 0 || fragment == 0) return false; + program_ = glCreateProgram(); + glAttachShader(program_, vertex); + glAttachShader(program_, fragment); + glLinkProgram(program_); + glDeleteShader(vertex); + glDeleteShader(fragment); + GLint linked = GL_FALSE; + glGetProgramiv(program_, GL_LINK_STATUS, &linked); + if (linked != GL_TRUE) return false; + uvTransformLocation_ = glGetUniformLocation(program_, "u"); + const float vertices[] = { + -1.0f, -1.0f, 0.0f, 1.0f, + 1.0f, -1.0f, 1.0f, 1.0f, + -1.0f, 1.0f, 0.0f, 0.0f, + 1.0f, 1.0f, 1.0f, 0.0f, + }; + glGenBuffers(1, &vertexBuffer_); + glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer_); + glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); + glGenVertexArrays(1, &vertexArray_); + glBindVertexArray(vertexArray_); + glEnableVertexAttribArray(0); + glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), reinterpret_cast(0)); + glEnableVertexAttribArray(1); + glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), + reinterpret_cast(2 * sizeof(float))); + glBindVertexArray(0); + glBindBuffer(GL_ARRAY_BUFFER, 0); + glUseProgram(program_); + glUniform1i(glGetUniformLocation(program_, "s"), 0); + glUseProgram(0); + return true; +} + +EGLImageKHR WindowsProjectionPresenter::createImageFromHardwareBuffer(AHardwareBuffer *buffer) { + EGLClientBuffer client = eglGetNativeClientBufferANDROID(buffer); + if (client == nullptr) return EGL_NO_IMAGE_KHR; + const EGLint attributes[] = {EGL_IMAGE_PRESERVED_KHR, EGL_TRUE, EGL_NONE}; + return eglCreateImageKHR(display_, EGL_NO_CONTEXT, EGL_NATIVE_BUFFER_ANDROID, client, attributes); +} + +EGLImageKHR WindowsProjectionPresenter::createImageFromDmabuf(const EyeFrame &frame) { + static constexpr EGLint planeFd[] = { + EGL_DMA_BUF_PLANE0_FD_EXT, EGL_DMA_BUF_PLANE1_FD_EXT, + EGL_DMA_BUF_PLANE2_FD_EXT, EGL_DMA_BUF_PLANE3_FD_EXT}; + static constexpr EGLint planeOffset[] = { + EGL_DMA_BUF_PLANE0_OFFSET_EXT, EGL_DMA_BUF_PLANE1_OFFSET_EXT, + EGL_DMA_BUF_PLANE2_OFFSET_EXT, EGL_DMA_BUF_PLANE3_OFFSET_EXT}; + static constexpr EGLint planePitch[] = { + EGL_DMA_BUF_PLANE0_PITCH_EXT, EGL_DMA_BUF_PLANE1_PITCH_EXT, + EGL_DMA_BUF_PLANE2_PITCH_EXT, EGL_DMA_BUF_PLANE3_PITCH_EXT}; + static constexpr EGLint modifierLow[] = { + EGL_DMA_BUF_PLANE0_MODIFIER_LO_EXT, EGL_DMA_BUF_PLANE1_MODIFIER_LO_EXT, + EGL_DMA_BUF_PLANE2_MODIFIER_LO_EXT, EGL_DMA_BUF_PLANE3_MODIFIER_LO_EXT}; + static constexpr EGLint modifierHigh[] = { + EGL_DMA_BUF_PLANE0_MODIFIER_HI_EXT, EGL_DMA_BUF_PLANE1_MODIFIER_HI_EXT, + EGL_DMA_BUF_PLANE2_MODIFIER_HI_EXT, EGL_DMA_BUF_PLANE3_MODIFIER_HI_EXT}; + EGLint attributes[64]; + int count = 0; + attributes[count++] = EGL_WIDTH; + attributes[count++] = frame.width; + attributes[count++] = EGL_HEIGHT; + attributes[count++] = frame.height; + attributes[count++] = EGL_LINUX_DRM_FOURCC_EXT; + attributes[count++] = static_cast(frame.fourcc); + for (int plane = 0; plane < frame.planeCount; ++plane) { + attributes[count++] = planeFd[plane]; + attributes[count++] = frame.dmabufFds[plane]; + attributes[count++] = planeOffset[plane]; + attributes[count++] = static_cast(frame.offsets[plane]); + attributes[count++] = planePitch[plane]; + attributes[count++] = static_cast(frame.strides[plane]); + if (frame.modifier != 0) { + attributes[count++] = modifierLow[plane]; + attributes[count++] = static_cast(frame.modifier & 0xffffffffu); + attributes[count++] = modifierHigh[plane]; + attributes[count++] = static_cast(frame.modifier >> 32); + } + } + attributes[count] = EGL_NONE; + return eglCreateImageKHR(display_, EGL_NO_CONTEXT, EGL_LINUX_DMA_BUF_EXT, nullptr, attributes); +} + +bool WindowsProjectionPresenter::waitForAcquireFence(int fenceFd) { + if (fenceFd < 0) return true; + const EGLint attributes[] = {EGL_SYNC_NATIVE_FENCE_FD_ANDROID, fenceFd, EGL_NONE}; + EGLSyncKHR sync = eglCreateSyncKHR(display_, EGL_SYNC_NATIVE_FENCE_ANDROID, attributes); + if (sync != EGL_NO_SYNC_KHR) { + const EGLBoolean result = eglWaitSyncKHR(display_, sync, 0); + eglDestroySyncKHR(display_, sync); + return result == EGL_TRUE; + } + pollfd descriptor{fenceFd, POLLIN, 0}; + int result; + do result = poll(&descriptor, 1, 5000); while (result < 0 && errno == EINTR); + close(fenceFd); + return result > 0; +} + +int WindowsProjectionPresenter::createReleaseFence() { + const auto duplicate = reinterpret_cast( + eglGetProcAddress("eglDupNativeFenceFDANDROID")); + if (duplicate == nullptr) { + glFinish(); + return -1; + } + const EGLint attributes[] = { + EGL_SYNC_NATIVE_FENCE_FD_ANDROID, EGL_NO_NATIVE_FENCE_FD_ANDROID, EGL_NONE}; + EGLSyncKHR sync = eglCreateSyncKHR(display_, EGL_SYNC_NATIVE_FENCE_ANDROID, attributes); + if (sync == EGL_NO_SYNC_KHR) { + glFinish(); + return -1; + } + glFlush(); + const int fd = duplicate(display_, sync); + eglDestroySyncKHR(display_, sync); + if (fd < 0) glFinish(); + return fd; +} + +bool WindowsProjectionPresenter::uploadLinearDmabufToTexture( + uint32_t eye, int imageIndex, const EyeFrame &frame, GLuint &texture, + uint64_t &cachedRegistration) { + if (frame.planeCount != 1 || frame.dmabufFds[0] < 0 || frame.modifier != 0 || + frame.width <= 0 || frame.height <= 0 || + frame.strides[0] < static_cast(frame.width) * 4u || + (frame.fourcc != kDrmFormatAbgr8888 && frame.fourcc != kDrmFormatArgb8888)) return false; + const size_t rowBytes = static_cast(frame.width) * 4u; + const size_t mapLength = static_cast(frame.offsets[0]) + + static_cast(frame.strides[0]) * static_cast(frame.height - 1) + rowBytes; + void *&mapping = cpuMappings_[eye][imageIndex]; + size_t &mappedLength = cpuMappingLengths_[eye][imageIndex]; + uint64_t &mappedRegistration = cpuMappingRegistrations_[eye][imageIndex]; + if (mapping != nullptr && + (mappedRegistration != frame.registrationSerial || mappedLength < mapLength)) { + munmap(mapping, mappedLength); + mapping = nullptr; + mappedLength = 0; + mappedRegistration = 0; + } + if (mapping == nullptr) { + mapping = mmap(nullptr, mapLength, PROT_READ, MAP_SHARED, frame.dmabufFds[0], 0); + if (mapping == MAP_FAILED) { + mapping = nullptr; + return false; + } + mappedLength = mapLength; + mappedRegistration = frame.registrationSerial; + } + if (texture == 0) glGenTextures(1, &texture); + glBindTexture(GL_TEXTURE_2D, texture); + const bool allocate = cpuTextureWidths_[eye][imageIndex] != frame.width || + cpuTextureHeights_[eye][imageIndex] != frame.height || + cachedRegistration != frame.registrationSerial; + if (allocate) { + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); + const bool swap = frame.fourcc == kDrmFormatArgb8888; + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, swap ? GL_BLUE : GL_RED); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G, GL_GREEN); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, swap ? GL_RED : GL_BLUE); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_A, GL_ALPHA); + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, frame.width, frame.height, 0, + GL_RGBA, GL_UNSIGNED_BYTE, nullptr); + } + DmaBufSync sync{kDmaBufSyncRead}; + ioctl(frame.dmabufFds[0], DMA_BUF_IOCTL_SYNC, &sync); + const auto *source = static_cast(mapping) + frame.offsets[0]; + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + glPixelStorei(GL_UNPACK_ROW_LENGTH, static_cast(frame.strides[0] / 4u)); + glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, frame.width, frame.height, + GL_RGBA, GL_UNSIGNED_BYTE, source); + glPixelStorei(GL_UNPACK_ROW_LENGTH, 0); + const GLenum error = glGetError(); + glBindTexture(GL_TEXTURE_2D, 0); + sync.flags = kDmaBufSyncRead | kDmaBufSyncEnd; + ioctl(frame.dmabufFds[0], DMA_BUF_IOCTL_SYNC, &sync); + if (error != GL_NO_ERROR) return false; + cpuTextureWidths_[eye][imageIndex] = frame.width; + cpuTextureHeights_[eye][imageIndex] = frame.height; + cachedRegistration = frame.registrationSerial; + return true; +} + +bool WindowsProjectionPresenter::importEyeBuffer(WindowsFrameTransport &transport, uint32_t eye, + EyeFrame &frame, bool &fresh) { + frame = transport.pollEye(static_cast(eye)); + if (frame.kind == BufferKind::None) return false; + fresh = frame.serial != renderedSerials_[eye]; + if (!waitForAcquireFence(frame.acquireFenceFd)) { + transport.discardFrame(static_cast(eye), frame.imageIndex, frame.serial); + if (fresh) renderedSerials_[eye] = frame.serial; + return false; + } + frame.acquireFenceFd = -1; + if (frame.imageIndex < 0 || frame.imageIndex >= WindowsFrameTransport::kMaxImages) { + transport.discardFrame(static_cast(eye), frame.imageIndex, frame.serial); + return false; + } + const int image = frame.imageIndex; + EGLImageKHR &cachedImage = eglImages_[eye][image]; + GLuint &cachedTexture = textures_[eye][image]; + uint64_t ®istration = registrations_[eye][image]; + if (cpuFallback_[eye][image]) { + if (!fresh && registration == frame.registrationSerial) return cachedTexture != 0; + if (uploadLinearDmabufToTexture(eye, image, frame, cachedTexture, registration)) return true; + } + if (cachedImage != EGL_NO_IMAGE_KHR && registration == frame.registrationSerial) return true; + if (cachedImage != EGL_NO_IMAGE_KHR) { + eglDestroyImageKHR(display_, cachedImage); + cachedImage = EGL_NO_IMAGE_KHR; + } + EGLImageKHR imported = EGL_NO_IMAGE_KHR; + if (frame.kind == BufferKind::HardwareBuffer && frame.buffer != nullptr) { + imported = createImageFromHardwareBuffer(frame.buffer); + } else if (frame.kind == BufferKind::DmaBuf && frame.planeCount > 0) { + imported = createImageFromDmabuf(frame); + if (imported == EGL_NO_IMAGE_KHR) { + cpuFallback_[eye][image] = true; + if (uploadLinearDmabufToTexture(eye, image, frame, cachedTexture, registration)) return true; + } + } + if (imported == EGL_NO_IMAGE_KHR) { + transport.discardFrame(static_cast(eye), image, frame.serial); + return false; + } + if (cachedTexture == 0) glGenTextures(1, &cachedTexture); + glBindTexture(GL_TEXTURE_2D, cachedTexture); + glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, imported); + const GLenum error = glGetError(); + if (error != GL_NO_ERROR) { + glBindTexture(GL_TEXTURE_2D, 0); + eglDestroyImageKHR(display_, imported); + transport.discardFrame(static_cast(eye), image, frame.serial); + return false; + } + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, frame.swapRedBlue ? GL_BLUE : GL_RED); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G, GL_GREEN); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, frame.swapRedBlue ? GL_RED : GL_BLUE); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_A, GL_ALPHA); + glBindTexture(GL_TEXTURE_2D, 0); + cachedImage = imported; + registration = frame.registrationSerial; + return true; +} + +void WindowsProjectionPresenter::drawEye(uint32_t eye, const EyeFrame &source, + uint32_t imageIndex) { + glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, images_[imageIndex].image, 0, eye); + glViewport(0, 0, static_cast(width_), static_cast(height_)); + glActiveTexture(GL_TEXTURE0); + glBindTexture(GL_TEXTURE_2D, textures_[eye][source.imageIndex]); + const float sourceWidth = source.sourceWidth > 0 ? source.sourceWidth : source.width; + const float sourceHeight = source.sourceHeight > 0 ? source.sourceHeight : source.height; + glUniform4f(uvTransformLocation_, source.sourceX / static_cast(source.width), + source.sourceY / static_cast(source.height), + sourceWidth / source.width, sourceHeight / source.height); + glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); +} + +void WindowsProjectionPresenter::discardFresh(WindowsFrameTransport &transport, + const std::array &frames, + const std::array &fresh) { + for (uint32_t eye = 0; eye < 2; ++eye) { + if (!fresh[eye]) continue; + transport.discardFrame(static_cast(eye), frames[eye].imageIndex, frames[eye].serial); + renderedSerials_[eye] = frames[eye].serial; + } +} + +bool WindowsProjectionPresenter::render(WindowsFrameTransport &transport, XrSpace space, + XrCompositionLayerProjection *layer) { + if (layer == nullptr || !transport.hasStereoContent()) return false; + std::array frames{}; + std::array fresh{false, false}; + for (uint32_t eye = 0; eye < 2; ++eye) { + if (!importEyeBuffer(transport, eye, frames[eye], fresh[eye])) { + discardFresh(transport, frames, fresh); + return false; + } + } + XrSwapchainImageAcquireInfo acquire{XR_TYPE_SWAPCHAIN_IMAGE_ACQUIRE_INFO}; + uint32_t imageIndex = 0; + if (XR_FAILED(xrAcquireSwapchainImage(swapchain_, &acquire, &imageIndex))) { + discardFresh(transport, frames, fresh); + return false; + } + XrSwapchainImageWaitInfo wait{XR_TYPE_SWAPCHAIN_IMAGE_WAIT_INFO}; + wait.timeout = XR_INFINITE_DURATION; + if (XR_FAILED(xrWaitSwapchainImage(swapchain_, &wait))) { + XrSwapchainImageReleaseInfo release{XR_TYPE_SWAPCHAIN_IMAGE_RELEASE_INFO}; + xrReleaseSwapchainImage(swapchain_, &release); + discardFresh(transport, frames, fresh); + return false; + } + glBindFramebuffer(GL_FRAMEBUFFER, framebuffer_); + glDisable(GL_DEPTH_TEST); + glDisable(GL_BLEND); + glDisable(GL_SCISSOR_TEST); + glUseProgram(program_); + glBindVertexArray(vertexArray_); + for (uint32_t eye = 0; eye < 2; ++eye) { + drawEye(eye, frames[eye], imageIndex); + XrCompositionLayerProjectionView &view = views_[eye]; + view = {XR_TYPE_COMPOSITION_LAYER_PROJECTION_VIEW}; + if (frames[eye].projectionValid) { + view.pose.orientation = { + frames[eye].projectionOrientation[0], frames[eye].projectionOrientation[1], + frames[eye].projectionOrientation[2], frames[eye].projectionOrientation[3]}; + view.pose.position = { + frames[eye].projectionPosition[0], frames[eye].projectionPosition[1], + frames[eye].projectionPosition[2]}; + view.fov = { + frames[eye].projectionFov[0], frames[eye].projectionFov[1], + frames[eye].projectionFov[2], frames[eye].projectionFov[3]}; + } + view.subImage.swapchain = swapchain_; + view.subImage.imageRect = {{0, 0}, {static_cast(width_), static_cast(height_)}}; + view.subImage.imageArrayIndex = eye; + } + glBindVertexArray(0); + glBindTexture(GL_TEXTURE_2D, 0); + glBindFramebuffer(GL_FRAMEBUFFER, 0); + const uint32_t freshCount = static_cast(fresh[0]) + static_cast(fresh[1]); + int sharedFence = freshCount > 0 ? createReleaseFence() : -1; + if (freshCount == 0) glFlush(); + std::array releaseFences{-1, -1}; + if (sharedFence >= 0) { + if (fresh[0] && fresh[1]) { + releaseFences[0] = dup(sharedFence); + releaseFences[1] = sharedFence; + if (releaseFences[0] < 0) { + close(sharedFence); + releaseFences = {-1, -1}; + glFinish(); + } + } else { + releaseFences[fresh[0] ? 0 : 1] = sharedFence; + } + } + for (uint32_t eye = 0; eye < 2; ++eye) { + if (!fresh[eye]) continue; + transport.publishReleaseFence(static_cast(eye), frames[eye].imageIndex, + releaseFences[eye]); + renderedSerials_[eye] = frames[eye].serial; + } + XrSwapchainImageReleaseInfo release{XR_TYPE_SWAPCHAIN_IMAGE_RELEASE_INFO}; + if (XR_FAILED(xrReleaseSwapchainImage(swapchain_, &release))) return false; + *layer = {XR_TYPE_COMPOSITION_LAYER_PROJECTION}; + layer->space = space; + layer->viewCount = 2; + layer->views = views_.data(); + return true; +} + +void WindowsProjectionPresenter::shutdown() { + for (uint32_t eye = 0; eye < 2; ++eye) { + for (int image = 0; image < WindowsFrameTransport::kMaxImages; ++image) { + if (eglImages_[eye][image] != EGL_NO_IMAGE_KHR) { + eglDestroyImageKHR(display_, eglImages_[eye][image]); + } + if (textures_[eye][image] != 0) glDeleteTextures(1, &textures_[eye][image]); + if (cpuMappings_[eye][image] != nullptr) { + munmap(cpuMappings_[eye][image], cpuMappingLengths_[eye][image]); + } + } + } + if (vertexArray_ != 0) glDeleteVertexArrays(1, &vertexArray_); + if (vertexBuffer_ != 0) glDeleteBuffers(1, &vertexBuffer_); + if (program_ != 0) glDeleteProgram(program_); + if (framebuffer_ != 0) glDeleteFramebuffers(1, &framebuffer_); + if (swapchain_ != XR_NULL_HANDLE) xrDestroySwapchain(swapchain_); + vertexArray_ = 0; + vertexBuffer_ = 0; + program_ = 0; + framebuffer_ = 0; + swapchain_ = XR_NULL_HANDLE; +} + +} diff --git a/app/src/main/cpp/xrimmersive/xr_windows_projection.h b/app/src/main/cpp/xrimmersive/xr_windows_projection.h new file mode 100644 index 0000000000..b951febbfd --- /dev/null +++ b/app/src/main/cpp/xrimmersive/xr_windows_projection.h @@ -0,0 +1,61 @@ +#pragma once + +#include "xr_windows_transport.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace xrimmersive::windowsvr { + +class WindowsProjectionPresenter { +public: + bool initialize(XrSession session, int64_t format, uint32_t width, uint32_t height, EGLDisplay display); + bool render(WindowsFrameTransport &transport, XrSpace space, XrCompositionLayerProjection *layer); + void shutdown(); + +private: + bool ensureProgram(); + EGLImageKHR createImageFromHardwareBuffer(AHardwareBuffer *buffer); + EGLImageKHR createImageFromDmabuf(const EyeFrame &frame); + bool waitForAcquireFence(int fenceFd); + int createReleaseFence(); + bool uploadLinearDmabufToTexture(uint32_t eye, int imageIndex, const EyeFrame &frame, + GLuint &texture, uint64_t &cachedRegistration); + bool importEyeBuffer(WindowsFrameTransport &transport, uint32_t eye, EyeFrame &frame, bool &fresh); + void drawEye(uint32_t eye, const EyeFrame &source, uint32_t imageIndex); + void discardFresh(WindowsFrameTransport &transport, const std::array &frames, + const std::array &fresh); + + XrSession session_ = XR_NULL_HANDLE; + XrSwapchain swapchain_ = XR_NULL_HANDLE; + uint32_t width_ = 0; + uint32_t height_ = 0; + EGLDisplay display_ = EGL_NO_DISPLAY; + std::vector images_; + std::array views_{}; + std::array, 2> eglImages_{}; + std::array, 2> textures_{}; + std::array, 2> registrations_{}; + std::array, 2> cpuFallback_{}; + std::array, 2> cpuMappings_{}; + std::array, 2> cpuMappingLengths_{}; + std::array, 2> cpuMappingRegistrations_{}; + std::array, 2> cpuTextureWidths_{}; + std::array, 2> cpuTextureHeights_{}; + std::array renderedSerials_{0, 0}; + GLuint framebuffer_ = 0; + GLuint program_ = 0; + GLuint vertexBuffer_ = 0; + GLuint vertexArray_ = 0; + GLint uvTransformLocation_ = -1; +}; + +} diff --git a/app/src/main/cpp/xrimmersive/xr_windows_transport.cpp b/app/src/main/cpp/xrimmersive/xr_windows_transport.cpp new file mode 100644 index 0000000000..2bac35db17 --- /dev/null +++ b/app/src/main/cpp/xrimmersive/xr_windows_transport.cpp @@ -0,0 +1,609 @@ +#include "xr_windows_transport.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define LOG_TAG "GameNativeVR" +#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__) +#define LOGW(...) __android_log_print(ANDROID_LOG_WARN, LOG_TAG, __VA_ARGS__) +#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__) + +namespace xrimmersive::windowsvr { +namespace { + + + + + +bool readLine(int fd, std::string& out) { + out.clear(); + char buffer[512]; + while (true) { + ssize_t got = recv(fd, buffer, sizeof(buffer), MSG_PEEK); + if (got == 0) return false; + if (got < 0) { + if (errno == EINTR) continue; + return false; + } + const void* newlinePtr = std::memchr(buffer, '\n', static_cast(got)); + const size_t consume = newlinePtr != nullptr + ? static_cast(newlinePtr) - buffer + 1 + : static_cast(got); + size_t consumed = 0; + while (consumed < consume) { + const ssize_t read = recv(fd, buffer + consumed, consume - consumed, 0); + if (read == 0) return false; + if (read < 0) { + if (errno == EINTR) continue; + return false; + } + consumed += static_cast(read); + } + const size_t textBytes = newlinePtr != nullptr ? consume - 1 : consume; + if (out.size() < 512) { + const size_t available = 512 - out.size(); + out.append(buffer, std::min(textBytes, available)); + } + if (newlinePtr != nullptr) return true; + } +} + +bool writeAll(int fd, const void* data, size_t len) { + const char* p = static_cast(data); + size_t sent = 0; + while (sent < len) { + ssize_t n = send(fd, p + sent, len - sent, MSG_NOSIGNAL); + if (n <= 0) { + if (n < 0 && errno == EINTR) continue; + return false; + } + sent += static_cast(n); + } + return true; +} + +bool replyOk(int fd) { return writeAll(fd, "OK\n", 3); } + + + + + +socklen_t fillUnixAddr(sockaddr_un& addr, const std::string& path, bool& abstractOut) { + std::memset(&addr, 0, sizeof(addr)); + addr.sun_family = AF_UNIX; + if (!path.empty() && path[0] == '@') { + abstractOut = true; + size_t nameLen = path.size() - 1; + if (nameLen > sizeof(addr.sun_path) - 1) nameLen = sizeof(addr.sun_path) - 1; + addr.sun_path[0] = '\0'; + std::memcpy(addr.sun_path + 1, path.data() + 1, nameLen); + return static_cast(offsetof(sockaddr_un, sun_path) + 1 + nameLen); + } + abstractOut = false; + std::strncpy(addr.sun_path, path.c_str(), sizeof(addr.sun_path) - 1); + return static_cast(sizeof(addr)); +} + + + +long long parseKey(const std::string& line, const char* key, long long fallback) { + std::string needle = std::string(key) + "="; + size_t pos = 0; + while ((pos = line.find(needle, pos)) != std::string::npos) { + if (pos == 0 || line[pos - 1] == ' ') { + pos += needle.size(); + return std::strtoll(line.c_str() + pos, nullptr, 0); + } + pos += needle.size(); + } + return fallback; +} + + + +int recvFd(int sockFd) { + char payload = 0; + iovec iov{}; + iov.iov_base = &payload; + iov.iov_len = 1; + + union { + char buf[CMSG_SPACE(sizeof(int))]; + cmsghdr align; + } control{}; + + msghdr msg{}; + msg.msg_iov = &iov; + msg.msg_iovlen = 1; + msg.msg_control = control.buf; + msg.msg_controllen = sizeof(control.buf); + + ssize_t n; + do { n = ::recvmsg(sockFd, &msg, 0); } while (n < 0 && errno == EINTR); + if (n <= 0) return -1; + + for (cmsghdr* c = CMSG_FIRSTHDR(&msg); c != nullptr; c = CMSG_NXTHDR(&msg, c)) { + if (c->cmsg_level == SOL_SOCKET && c->cmsg_type == SCM_RIGHTS && + c->cmsg_len == CMSG_LEN(sizeof(int))) { + int fd = -1; + std::memcpy(&fd, CMSG_DATA(c), sizeof(int)); + return fd; + } + } + return -1; +} + +bool sendFd(int sockFd, int fd) { + char payload = 'F'; + iovec iov{}; + iov.iov_base = &payload; + iov.iov_len = 1; + union { + char buf[CMSG_SPACE(sizeof(int))]; + cmsghdr align; + } control{}; + msghdr msg{}; + msg.msg_iov = &iov; + msg.msg_iovlen = 1; + msg.msg_control = control.buf; + msg.msg_controllen = sizeof(control.buf); + cmsghdr* cmsg = CMSG_FIRSTHDR(&msg); + cmsg->cmsg_level = SOL_SOCKET; + cmsg->cmsg_type = SCM_RIGHTS; + cmsg->cmsg_len = CMSG_LEN(sizeof(int)); + std::memcpy(CMSG_DATA(cmsg), &fd, sizeof(fd)); + ssize_t sent; + do { sent = ::sendmsg(sockFd, &msg, MSG_NOSIGNAL); } while (sent < 0 && errno == EINTR); + return sent == 1; +} + +} + +WindowsFrameTransport::WindowsFrameTransport() { + for (int eye = 0; eye < kEyeCount; ++eye) { + for (int image = 0; image < kMaxImages; ++image) { + releaseFenceFds_[eye][image] = -1; + } + } +} + +WindowsFrameTransport::~WindowsFrameTransport() { stop(); } + +void WindowsFrameTransport::start(const std::string& socketPath) { + bool expected = false; + if (!running_.compare_exchange_strong(expected, true)) return; + socketPath_ = socketPath; + acceptThread_ = std::thread([this] { acceptLoop(); }); +} + +void WindowsFrameTransport::stop() { + if (!running_.exchange(false)) return; + releaseCv_.notify_all(); + int client = clientFd_.exchange(-1); + if (client >= 0) ::shutdown(client, SHUT_RDWR); + int fd = listenFd_.exchange(-1); + if (fd >= 0) { + ::shutdown(fd, SHUT_RDWR); + ::close(fd); + } + if (acceptThread_.joinable()) acceptThread_.join(); + for (int eye = 0; eye < kEyeCount; ++eye) releaseEye(eye); +} + +void WindowsFrameTransport::acceptLoop() { + int listenFd = ::socket(AF_UNIX, SOCK_STREAM, 0); + if (listenFd < 0) { + LOGE("xr transport: socket() failed: %s", strerror(errno)); + running_ = false; + return; + } + + sockaddr_un addr{}; + bool abstract = false; + socklen_t addrLen = fillUnixAddr(addr, socketPath_, abstract); + if (!abstract) ::unlink(socketPath_.c_str()); + + if (::bind(listenFd, reinterpret_cast(&addr), addrLen) != 0) { + LOGE("xr transport: bind(%s) failed: %s", socketPath_.c_str(), strerror(errno)); + ::close(listenFd); + running_ = false; + return; + } + if (::listen(listenFd, 1) != 0) { + LOGE("xr transport: listen() failed: %s", strerror(errno)); + ::close(listenFd); + running_ = false; + return; + } + listenFd_ = listenFd; + LOGI("xr transport listening on %s", socketPath_.c_str()); + + while (running_.load()) { + int clientFd = ::accept(listenFd, nullptr, nullptr); + if (clientFd < 0) { + if (errno == EINTR) continue; + break; + } + LOGI("xr transport: producer connected"); + clientFd_ = clientFd; + serviceClient(clientFd); + int expectedClient = clientFd; + clientFd_.compare_exchange_strong(expectedClient, -1); + ::close(clientFd); + for (int eye = 0; eye < kEyeCount; ++eye) releaseEye(eye); + LOGI("xr transport: producer disconnected"); + } + + int fd = listenFd_.exchange(-1); + if (fd >= 0) ::close(fd); + if (!abstract) ::unlink(socketPath_.c_str()); +} + +void WindowsFrameTransport::serviceClient(int clientFd) { + std::string line; + while (running_.load() && readLine(clientFd, line)) { + if (line.rfind("HELLO", 0) == 0) { + writeAll(clientFd, "OK GameNativeVR 2\n", 18); + } else if (line.rfind("BUFFER", 0) == 0) { + if (!handleBufferLine(clientFd, line)) { + writeAll(clientFd, "ERR buffer\n", 11); + return; + } + } else if (line.rfind("DMABUF", 0) == 0) { + if (!handleDmabufLine(clientFd, line)) { + writeAll(clientFd, "ERR dmabuf\n", 11); + return; + } + } else if (line.rfind("FRAME", 0) == 0) { + if (!handleFrameLine(clientFd, line)) return; + } else if (line.rfind("ACQUIRE", 0) == 0) { + if (!handleAcquireLine(clientFd, line)) return; + } else if (line.rfind("BYE", 0) == 0) { + replyOk(clientFd); + return; + } else { + writeAll(clientFd, "ERR unknown\n", 12); + } + } +} + +bool WindowsFrameTransport::handleBufferLine(int clientFd, const std::string& line) { + long long eye = parseKey(line, "eye", -1); + long long index = parseKey(line, "index", 0); + long long w = parseKey(line, "w", 0); + long long h = parseKey(line, "h", 0); + const bool swapRedBlue = parseKey(line, "swizzle", 0) != 0; + if (eye < 0 || eye >= kEyeCount || index < 0 || index >= kMaxImages || + w <= 0 || h <= 0) { + LOGE("xr transport: bad BUFFER line: %s", line.c_str()); + return false; + } + + if (!replyOk(clientFd)) return false; + + AHardwareBuffer* ahb = nullptr; + if (AHardwareBuffer_recvHandleFromUnixSocket(clientFd, &ahb) != 0 || ahb == nullptr) { + LOGE("xr transport: recvHandleFromUnixSocket failed for eye %lld", eye); + return false; + } + + storeEyeBuffer(static_cast(eye), ahb, + static_cast(w), static_cast(h), + static_cast(index), swapRedBlue); + LOGI("xr transport: received eye %lld AHB buffer %lldx%lld index=%lld", eye, w, h, index); + return writeAll(clientFd, "OK stored\n", 10); +} + +bool WindowsFrameTransport::handleDmabufLine(int clientFd, const std::string& line) { + long long eye = parseKey(line, "eye", -1); + long long imageIndex = parseKey(line, "index", -1); + long long w = parseKey(line, "w", 0); + long long h = parseKey(line, "h", 0); + long long planeCount = parseKey(line, "planes", 1); + if (eye < 0 || eye >= kEyeCount || imageIndex < 0 || imageIndex >= kMaxImages || + w <= 0 || h <= 0 || planeCount < 1 || planeCount > EyeFrame::kMaxPlanes) { + LOGE("xr transport: bad DMABUF line: %s", line.c_str()); + return false; + } + + EyeFrame frame; + frame.kind = BufferKind::DmaBuf; + frame.width = static_cast(w); + frame.height = static_cast(h); + frame.imageIndex = static_cast(imageIndex); + frame.planeCount = static_cast(planeCount); + frame.fourcc = static_cast(parseKey(line, "fourcc", 0)); + frame.modifier = static_cast(parseKey(line, "modifier", 0)); + for (int plane = 0; plane < frame.planeCount; ++plane) { + char strideKey[16]; + char offsetKey[16]; + std::snprintf(strideKey, sizeof(strideKey), "stride%d", plane); + std::snprintf(offsetKey, sizeof(offsetKey), "offset%d", plane); + frame.strides[plane] = static_cast( + parseKey(line, strideKey, plane == 0 ? parseKey(line, "stride", w * 4) : 0)); + frame.offsets[plane] = static_cast( + parseKey(line, offsetKey, plane == 0 ? parseKey(line, "offset", 0) : 0)); + } + + if (!replyOk(clientFd)) return false; + for (int plane = 0; plane < frame.planeCount; ++plane) { + frame.dmabufFds[plane] = recvFd(clientFd); + if (frame.dmabufFds[plane] < 0) { + for (int received = 0; received < plane; ++received) ::close(frame.dmabufFds[received]); + LOGE("xr transport: recvFd (dma-buf plane %d) failed for eye %lld", plane, eye); + return false; + } + } + + storeEyeDmabuf(static_cast(eye), frame); + LOGI("xr transport: received eye %lld dma-buf %lldx%lld fourcc=0x%08x planes=%d mod=0x%llx", + eye, w, h, frame.fourcc, frame.planeCount, + static_cast(frame.modifier)); + return writeAll(clientFd, "OK stored\n", 10); +} + +bool WindowsFrameTransport::handleFrameLine(int clientFd, const std::string& line) { + const long long eye = parseKey(line, "eye", -1); + const long long index = parseKey(line, "index", -1); + const bool hasFence = parseKey(line, "fence", 0) != 0; + if (eye < 0 || eye >= kEyeCount || index < 0 || index >= kMaxImages) { + writeAll(clientFd, "ERR frame\n", 10); + return true; + } + + int acquireFenceFd = -1; + if (hasFence) { + if (!replyOk(clientFd)) return false; + acquireFenceFd = recvFd(clientFd); + if (acquireFenceFd < 0) return false; + } + + { + std::lock_guard lock(eyesMutex_); + EyeFrame& registered = buffers_[eye][index]; + if (registered.kind == BufferKind::None) { + if (acquireFenceFd >= 0) ::close(acquireFenceFd); + writeAll(clientFd, "ERR unregistered\n", 17); + return true; + } + const long long sourceX = parseKey(line, "x", 0); + const long long sourceY = parseKey(line, "y", 0); + const long long sourceWidth = parseKey(line, "w", registered.width); + const long long sourceHeight = parseKey(line, "h", registered.height); + if (sourceX < 0 || sourceY < 0 || sourceWidth <= 0 || sourceHeight <= 0 || + sourceX + sourceWidth > registered.width || + sourceY + sourceHeight > registered.height) { + if (acquireFenceFd >= 0) ::close(acquireFenceFd); + writeAll(clientFd, "ERR rect\n", 9); + return true; + } + if (latest_[eye].acquireFenceFd >= 0) { + ::close(latest_[eye].acquireFenceFd); + } + if (latest_[eye].kind != BufferKind::None && !latestClaimed_[eye]) { + const int dropped = latest_[eye].imageIndex; + if (dropped >= 0 && dropped < kMaxImages && + releasePending_[eye][dropped]) { + releasePending_[eye][dropped] = false; + if (releaseFenceFds_[eye][dropped] >= 0) { + ::close(releaseFenceFds_[eye][dropped]); + releaseFenceFds_[eye][dropped] = -1; + } + } + } + latest_[eye] = registered; + latest_[eye].sourceX = static_cast(sourceX); + latest_[eye].sourceY = static_cast(sourceY); + latest_[eye].sourceWidth = static_cast(sourceWidth); + latest_[eye].sourceHeight = static_cast(sourceHeight); + latest_[eye].projectionValid = + parseKey(line, "projection", 0) != 0; + if (latest_[eye].projectionValid) { + static constexpr const char* kOrientationKeys[4] = { + "qx", "qy", "qz", "qw"}; + static constexpr const char* kPositionKeys[3] = { + "px", "py", "pz"}; + static constexpr const char* kFovKeys[4] = { + "fl", "fr", "fu", "fd"}; + for (int component = 0; component < 4; ++component) { + latest_[eye].projectionOrientation[component] = + static_cast(parseKey( + line, kOrientationKeys[component], + component == 3 ? 1000000 : 0)) / 1000000.0f; + latest_[eye].projectionFov[component] = + static_cast(parseKey( + line, kFovKeys[component], + component == 0 || component == 3 + ? -750000 : 750000)) / 1000000.0f; + } + for (int component = 0; component < 3; ++component) { + latest_[eye].projectionPosition[component] = + static_cast(parseKey( + line, kPositionKeys[component], 0)) / 1000000.0f; + } + } + latest_[eye].acquireFenceFd = acquireFenceFd; + latest_[eye].serial = nextSerial_++; + latestClaimed_[eye] = false; + if (releaseFenceFds_[eye][index] >= 0) { + ::close(releaseFenceFds_[eye][index]); + releaseFenceFds_[eye][index] = -1; + } + releasePending_[eye][index] = true; + } + releaseCv_.notify_all(); + return writeAll(clientFd, hasFence ? "OK stored\n" : "OK\n", + hasFence ? 10 : 3); +} + +bool WindowsFrameTransport::handleAcquireLine(int clientFd, const std::string& line) { + const long long eye = parseKey(line, "eye", -1); + const long long index = parseKey(line, "index", -1); + const long long timeoutMs = parseKey(line, "timeout", 5000); + if (eye < 0 || eye >= kEyeCount || index < 0 || index >= kMaxImages) { + return writeAll(clientFd, "ERR acquire\n", 12); + } + + std::unique_lock lock(eyesMutex_); + const auto ready = [this, eye, index] { + return !running_.load() || + !releasePending_[eye][index] || + releaseFenceFds_[eye][index] >= 0; + }; + bool signaled; + if (timeoutMs < 0) { + releaseCv_.wait(lock, ready); + signaled = true; + } else { + signaled = releaseCv_.wait_for( + lock, std::chrono::milliseconds(timeoutMs), ready); + } + if (!signaled) { + LOGW("xr transport: timed out waiting for release eye=%lld index=%lld", eye, index); + return writeAll(clientFd, "ERR timeout\n", 12); + } + if (!running_.load()) return false; + + const int fenceFd = releaseFenceFds_[eye][index]; + releaseFenceFds_[eye][index] = -1; + releasePending_[eye][index] = false; + lock.unlock(); + + if (fenceFd < 0) return writeAll(clientFd, "OK fence=0\n", 11); + const bool sent = writeAll(clientFd, "OK fence=1\n", 11) && + sendFd(clientFd, fenceFd); + ::close(fenceFd); + return sent; +} + + +void WindowsFrameTransport::releaseSlotLocked(int eye, int imageIndex) { + EyeFrame& slot = buffers_[eye][imageIndex]; + if (slot.kind == BufferKind::HardwareBuffer && slot.buffer != nullptr) { + AHardwareBuffer_release(slot.buffer); + } else if (slot.kind == BufferKind::DmaBuf) { + for (int plane = 0; plane < slot.planeCount; ++plane) { + if (slot.dmabufFds[plane] >= 0) ::close(slot.dmabufFds[plane]); + } + } + if (slot.acquireFenceFd >= 0) ::close(slot.acquireFenceFd); + slot = EyeFrame{}; + if (releaseFenceFds_[eye][imageIndex] >= 0) { + ::close(releaseFenceFds_[eye][imageIndex]); + releaseFenceFds_[eye][imageIndex] = -1; + } + releasePending_[eye][imageIndex] = false; +} + +void WindowsFrameTransport::storeEyeBuffer(int eye, AHardwareBuffer* ahb, + int32_t w, int32_t h, int32_t index, + bool swapRedBlue) { + std::lock_guard lock(eyesMutex_); + if (latest_[eye].kind != BufferKind::None && + latest_[eye].imageIndex == index) { + if (latest_[eye].acquireFenceFd >= 0) + ::close(latest_[eye].acquireFenceFd); + latest_[eye] = EyeFrame{}; + latestClaimed_[eye] = false; + } + releaseSlotLocked(eye, index); + EyeFrame& slot = buffers_[eye][index]; + slot.kind = BufferKind::HardwareBuffer; + slot.buffer = ahb; + slot.swapRedBlue = swapRedBlue; + slot.width = w; + slot.height = h; + slot.imageIndex = index; + slot.registrationSerial = nextSerial_++; +} + +void WindowsFrameTransport::storeEyeDmabuf(int eye, const EyeFrame& incoming) { + std::lock_guard lock(eyesMutex_); + if (latest_[eye].kind != BufferKind::None && + latest_[eye].imageIndex == incoming.imageIndex) { + if (latest_[eye].acquireFenceFd >= 0) + ::close(latest_[eye].acquireFenceFd); + latest_[eye] = EyeFrame{}; + latestClaimed_[eye] = false; + } + releaseSlotLocked(eye, incoming.imageIndex); + buffers_[eye][incoming.imageIndex] = incoming; + buffers_[eye][incoming.imageIndex].registrationSerial = nextSerial_++; +} + +void WindowsFrameTransport::releaseEye(int eye) { + std::lock_guard lock(eyesMutex_); + if (latest_[eye].acquireFenceFd >= 0) { + ::close(latest_[eye].acquireFenceFd); + } + latest_[eye] = EyeFrame{}; + latestClaimed_[eye] = false; + for (int image = 0; image < kMaxImages; ++image) { + releaseSlotLocked(eye, image); + } + releaseCv_.notify_all(); +} + +EyeFrame WindowsFrameTransport::pollEye(int eye) { + if (eye < 0 || eye >= kEyeCount) return EyeFrame{}; + std::lock_guard lock(eyesMutex_); + EyeFrame snapshot = latest_[eye]; + latest_[eye].acquireFenceFd = -1; + if (snapshot.kind != BufferKind::None) latestClaimed_[eye] = true; + return snapshot; +} + +void WindowsFrameTransport::publishReleaseFence(int eye, int imageIndex, int releaseFenceFd) { + if (eye < 0 || eye >= kEyeCount || + imageIndex < 0 || imageIndex >= kMaxImages) { + if (releaseFenceFd >= 0) ::close(releaseFenceFd); + return; + } + { + std::lock_guard lock(eyesMutex_); + if (releaseFenceFds_[eye][imageIndex] >= 0) { + ::close(releaseFenceFds_[eye][imageIndex]); + } + releaseFenceFds_[eye][imageIndex] = releaseFenceFd; + if (releaseFenceFd < 0) releasePending_[eye][imageIndex] = false; + } + releaseCv_.notify_all(); +} + +void WindowsFrameTransport::discardFrame(int eye, int imageIndex, uint64_t serial) { + if (eye < 0 || eye >= kEyeCount || + imageIndex < 0 || imageIndex >= kMaxImages) return; + { + std::lock_guard lock(eyesMutex_); + if (latest_[eye].serial == serial && + latest_[eye].imageIndex == imageIndex) { + if (latest_[eye].acquireFenceFd >= 0) + ::close(latest_[eye].acquireFenceFd); + latest_[eye] = EyeFrame{}; + latestClaimed_[eye] = true; + } + if (releaseFenceFds_[eye][imageIndex] >= 0) { + ::close(releaseFenceFds_[eye][imageIndex]); + releaseFenceFds_[eye][imageIndex] = -1; + } + releasePending_[eye][imageIndex] = false; + } + releaseCv_.notify_all(); +} + +bool WindowsFrameTransport::hasStereoContent() const { + std::lock_guard lock(const_cast(eyesMutex_)); + return latest_[0].kind != BufferKind::None && + latest_[1].kind != BufferKind::None; +} + +} diff --git a/app/src/main/cpp/xrimmersive/xr_windows_transport.h b/app/src/main/cpp/xrimmersive/xr_windows_transport.h new file mode 100644 index 0000000000..b26115eac1 --- /dev/null +++ b/app/src/main/cpp/xrimmersive/xr_windows_transport.h @@ -0,0 +1,119 @@ + + + + + + + + + + + + + + + + + +#pragma once + +#include + +#include +#include +#include +#include +#include + +namespace xrimmersive::windowsvr { + + + +enum class BufferKind { None, HardwareBuffer, DmaBuf }; + + + + +struct EyeFrame { + static constexpr int kMaxPlanes = 4; + BufferKind kind{BufferKind::None}; + + AHardwareBuffer* buffer{nullptr}; + bool swapRedBlue{false}; + + int planeCount{0}; + int dmabufFds[kMaxPlanes]{-1, -1, -1, -1}; + uint32_t fourcc{0}; + uint32_t strides[kMaxPlanes]{0, 0, 0, 0}; + uint32_t offsets[kMaxPlanes]{0, 0, 0, 0}; + uint64_t modifier{0}; + + int32_t width{0}; + int32_t height{0}; + int32_t sourceX{0}; + int32_t sourceY{0}; + int32_t sourceWidth{0}; + int32_t sourceHeight{0}; + bool projectionValid{false}; + float projectionOrientation[4]{0.0f, 0.0f, 0.0f, 1.0f}; + float projectionPosition[3]{0.0f, 0.0f, 0.0f}; + float projectionFov[4]{-0.75f, 0.75f, 0.75f, -0.75f}; + int32_t imageIndex{0}; + int32_t acquireFenceFd{-1}; + uint64_t registrationSerial{0}; + uint64_t serial{0}; +}; + +class WindowsFrameTransport { +public: + static constexpr int kEyeCount = 2; + static constexpr int kMaxImages = 128; + + WindowsFrameTransport(); + ~WindowsFrameTransport(); + + WindowsFrameTransport(const WindowsFrameTransport&) = delete; + WindowsFrameTransport& operator=(const WindowsFrameTransport&) = delete; + + void start(const std::string& socketPath); + + void stop(); + + EyeFrame pollEye(int eye); + + void publishReleaseFence(int eye, int imageIndex, int releaseFenceFd); + + void discardFrame(int eye, int imageIndex, uint64_t serial); + + bool hasStereoContent() const; + +private: + void acceptLoop(); + void serviceClient(int clientFd); + bool handleBufferLine(int clientFd, const std::string& line); + bool handleDmabufLine(int clientFd, const std::string& line); + bool handleFrameLine(int clientFd, const std::string& line); + bool handleAcquireLine(int clientFd, const std::string& line); + void storeEyeBuffer(int eye, AHardwareBuffer* ahb, int32_t w, int32_t h, + int32_t index, bool swapRedBlue); + void storeEyeDmabuf(int eye, const EyeFrame& incoming); + void releaseSlotLocked(int eye, int imageIndex); + void releaseEye(int eye); + + std::string socketPath_; + std::atomic running_{false}; + std::atomic listenFd_{-1}; + std::atomic clientFd_{-1}; + std::thread acceptThread_; + + std::mutex eyesMutex_; + std::condition_variable releaseCv_; + EyeFrame buffers_[kEyeCount][kMaxImages]; + EyeFrame latest_[kEyeCount]; + bool latestClaimed_[kEyeCount]{false, false}; + int releaseFenceFds_[kEyeCount][kMaxImages]; + bool releasePending_[kEyeCount][kMaxImages]{}; + uint64_t nextSerial_{1}; +}; + +} diff --git a/app/src/main/java/app/gamenative/ui/component/QuickMenu.kt b/app/src/main/java/app/gamenative/ui/component/QuickMenu.kt index 0bdbfd4025..dd0d7c945c 100644 --- a/app/src/main/java/app/gamenative/ui/component/QuickMenu.kt +++ b/app/src/main/java/app/gamenative/ui/component/QuickMenu.kt @@ -1689,6 +1689,38 @@ private fun ImmersiveQuickMenuTab( verticalArrangement = Arrangement.spacedBy(4.dp), ) { // ── Passthrough ──────────────────────────────────────────────── + QuickMenuSectionHeader( + title = stringResource(R.string.immersive_windows_vr_title), + subtitle = "${controls.windowsVrStatus} · ${controls.windowsVrRuntimePath}", + ) + QuickMenuToggleRow( + title = stringResource(R.string.immersive_windows_vr_toggle), + enabled = controls.windowsVrEnabled, + onToggle = { controls.onWindowsVrToggle(!controls.windowsVrEnabled) }, + accentColor = accentColor, + focusRequester = focusRequester, + ) + QuickMenuToggleRow( + title = stringResource(R.string.immersive_openvr_compatibility_toggle), + enabled = controls.openCompositeEnabled, + onToggle = { controls.onOpenCompositeToggle(!controls.openCompositeEnabled) }, + accentColor = accentColor, + ) + Text( + text = stringResource(R.string.immersive_windows_vr_restart_required), + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + modifier = Modifier.padding(horizontal = 16.dp, vertical = 4.dp), + ) + QuickMenuDetailRow( + title = stringResource(R.string.immersive_windows_vr_export), + subtitle = stringResource(R.string.immersive_windows_vr_export_desc), + accentColor = accentColor, + onActivate = controls.onExportWindowsVrDiagnostics, + ) + + Spacer(modifier = Modifier.height(4.dp)) + QuickMenuSectionHeader( title = stringResource(R.string.immersive_passthrough), subtitle = stringResource(R.string.immersive_passthrough_desc), @@ -1698,7 +1730,6 @@ private fun ImmersiveQuickMenuTab( enabled = controls.passthroughEnabled, onToggle = { controls.onPassthroughToggle(!controls.passthroughEnabled) }, accentColor = accentColor, - focusRequester = focusRequester, ) Spacer(modifier = Modifier.height(4.dp)) diff --git a/app/src/main/java/app/gamenative/ui/screen/xr/ImmersiveControls.kt b/app/src/main/java/app/gamenative/ui/screen/xr/ImmersiveControls.kt index 6b56dfa67c..43757c24a7 100644 --- a/app/src/main/java/app/gamenative/ui/screen/xr/ImmersiveControls.kt +++ b/app/src/main/java/app/gamenative/ui/screen/xr/ImmersiveControls.kt @@ -12,6 +12,13 @@ data class ImmersiveControls( val onResetScreenEffects: () -> Unit = {}, val resizeModeEnabled: Boolean = false, val onResizeModeToggle: (Boolean) -> Unit = {}, + val windowsVrEnabled: Boolean = true, + val onWindowsVrToggle: (Boolean) -> Unit = {}, + val openCompositeEnabled: Boolean = false, + val onOpenCompositeToggle: (Boolean) -> Unit = {}, + val windowsVrStatus: String = "Waiting for runtime", + val windowsVrRuntimePath: String = "Native OpenXR", + val onExportWindowsVrDiagnostics: () -> Unit = {}, ) { companion object { const val MIN_DISTANCE = 1.0f diff --git a/app/src/main/java/app/gamenative/ui/screen/xr/ImmersiveSessionHooks.kt b/app/src/main/java/app/gamenative/ui/screen/xr/ImmersiveSessionHooks.kt index 9c3d5194c7..68e6315423 100644 --- a/app/src/main/java/app/gamenative/ui/screen/xr/ImmersiveSessionHooks.kt +++ b/app/src/main/java/app/gamenative/ui/screen/xr/ImmersiveSessionHooks.kt @@ -13,6 +13,7 @@ import androidx.compose.ui.focus.FocusManager */ class ImmersiveSessionHooks( val controls: ImmersiveControls, + val windowsVr: app.gamenative.ui.screen.xr.windows.WindowsVrRuntimeService? = null, val onQuickMenuVisibilityChanged: (Boolean) -> Unit = {}, val registerFocusManager: ((FocusManager) -> Unit)? = null, val registerCycleTab: (((Boolean) -> Unit) -> Unit)? = null, diff --git a/app/src/main/java/app/gamenative/ui/screen/xr/ImmersiveXrActivity.kt b/app/src/main/java/app/gamenative/ui/screen/xr/ImmersiveXrActivity.kt index eac33e1022..5475492392 100644 --- a/app/src/main/java/app/gamenative/ui/screen/xr/ImmersiveXrActivity.kt +++ b/app/src/main/java/app/gamenative/ui/screen/xr/ImmersiveXrActivity.kt @@ -76,6 +76,7 @@ class ImmersiveXrActivity : androidx.activity.ComponentActivity() { private const val POLL_INTERVAL_MS = 11L private const val CAPTURE_RETRY_DELAY_MS = 200L private const val OVERLAY_REFRESH_INTERVAL_MS = 33L // ~30fps — plenty for a menu/HUD, + private const val OVERLAY_IDLE_REFRESH_INTERVAL_MS = 250L private const val OVERLAY_CONTENT_GRACE_MS = 2500L private const val IMMERSIVE_UI_DENSITY = 2.5f @@ -98,6 +99,8 @@ class ImmersiveXrActivity : androidx.activity.ComponentActivity() { private const val EXTRA_QUAD_DISTANCE = "immersiveQuadDistance" private const val EXTRA_QUAD_SCALE = "immersiveQuadScale" private const val EXTRA_PASSTHROUGH_ENABLED = "immersivePassthroughEnabled" + private const val EXTRA_WINDOWS_VR_ENABLED = "windowsVrEnabled" + private const val EXTRA_WINDOWS_VR_OPEN_COMPOSITE = "windowsVrOpenCompositeEnabled" fun start(context: Context, appId: String, isOffline: Boolean) { val intent = Intent(context, ImmersiveXrActivity::class.java).apply { @@ -174,8 +177,11 @@ class ImmersiveXrActivity : androidx.activity.ComponentActivity() { private var directGLBridge: DirectGLBridge? = null private var directVulkanBridge: DirectVulkanBridge? = null private var bridgedRenderer: Any? = null + private var windowsVrRuntimeService: app.gamenative.ui.screen.xr.windows.WindowsVrRuntimeService? = null @Volatile private var directRenderActive = false + @Volatile + private var flatPresentationSuspended = false private var directRenderProbeLogged = false private var lastMenuDpadKeyCode: Int? = null @@ -219,6 +225,9 @@ class ImmersiveXrActivity : androidx.activity.ComponentActivity() { private var quadVertical by mutableFloatStateOf(ImmersiveControls.DEFAULT_OFFSET) private var quadScale by mutableFloatStateOf(ImmersiveControls.DEFAULT_SCALE) private var passthroughEnabled by mutableStateOf(false) + private var windowsVrEnabled by mutableStateOf(true) + private var openCompositeEnabled by mutableStateOf(false) + private var windowsVrStatus by mutableStateOf("Waiting for runtime") private var showControlsOnboarding by mutableStateOf(false) private var mappedWindowCount by androidx.compose.runtime.mutableIntStateOf(0) private var overlayPausedUi by mutableStateOf(false) @@ -247,6 +256,7 @@ class ImmersiveXrActivity : androidx.activity.ComponentActivity() { return } currentAppId = appId + windowsVrRuntimeService = app.gamenative.ui.screen.xr.windows.WindowsVrRuntimeService(this) PluviaApp.isActivityInForeground = true AppUtils.keepScreenOn(this) @@ -284,17 +294,20 @@ class ImmersiveXrActivity : androidx.activity.ComponentActivity() { }, onGameLaunchError = { error -> viewModel.onGameLaunchError(error) - finish() + runOnUiThread { windowsVrStatus = "Guest stopped: $error" } + windowsVrRuntimeService?.onGuestProcessError(error) }, immersiveHooks = ImmersiveSessionHooks( - onQuickMenuVisibilityChanged = { visible -> - Timber.i("Immersive: quick menu visibility changed to %b", visible) - quickMenuVisible = visible - if (visible) { - directRenderBlockedByEffects = (PluviaApp.xServerView?.renderer as? com.winlator.renderer.VulkanRenderer) - ?.isEffectsRequireCompositor() - } - }, + windowsVr = windowsVrRuntimeService, + onQuickMenuVisibilityChanged = { visible -> + Timber.i("Immersive: quick menu visibility changed to %b", visible) + quickMenuVisible = visible + if (xrSessionHandle != 0L) XrNative.nativeSetWindowsOverlayVisible(xrSessionHandle, visible) + if (visible) { + directRenderBlockedByEffects = (PluviaApp.xServerView?.renderer as? com.winlator.renderer.VulkanRenderer) + ?.isEffectsRequireCompositor() + } + }, registerToggle = { toggle -> quickMenuToggle = toggle }, registerStartHeld = { setter -> quickMenuSetStartHeld = setter }, registerFocusManager = { fm -> quickMenuFocusManager = fm }, @@ -331,6 +344,25 @@ class ImmersiveXrActivity : androidx.activity.ComponentActivity() { } Timber.i("Immersive: resize handles toggled %s from quick menu, pointer mode now %s", enabled, enabled) }, + windowsVrEnabled = windowsVrEnabled, + onWindowsVrToggle = { enabled -> + windowsVrEnabled = enabled + windowsVrStatus = if (enabled) "Restart required" else "Disabled" + persistImmersiveSettings(appId) + }, + openCompositeEnabled = openCompositeEnabled, + onOpenCompositeToggle = { enabled -> + openCompositeEnabled = enabled + windowsVrStatus = "Restart required" + persistImmersiveSettings(appId) + }, + windowsVrStatus = windowsVrStatus, + windowsVrRuntimePath = if (openCompositeEnabled) "OpenVR compatibility" else "Native OpenXR", + onExportWindowsVrDiagnostics = { + val result = runCatching { windowsVrRuntimeService?.exportDiagnostics() } + val message = result.getOrNull()?.path ?: result.exceptionOrNull()?.message ?: "Windows VR is inactive" + app.gamenative.ui.util.SnackbarManager.show(message) + }, ), ), ) @@ -369,6 +401,9 @@ class ImmersiveXrActivity : androidx.activity.ComponentActivity() { quadScale = container.getExtra(EXTRA_QUAD_SCALE, ImmersiveControls.DEFAULT_SCALE.toString()) .toFloatOrNull() ?: ImmersiveControls.DEFAULT_SCALE passthroughEnabled = container.getExtra(EXTRA_PASSTHROUGH_ENABLED, "false").toBoolean() + windowsVrEnabled = container.getExtra(EXTRA_WINDOWS_VR_ENABLED, "true").toBoolean() + openCompositeEnabled = container.getExtra(EXTRA_WINDOWS_VR_OPEN_COMPOSITE, "false").toBoolean() + windowsVrStatus = if (windowsVrEnabled) "Waiting for runtime" else "Disabled" applyQuadTransform() if (xrSessionHandle != 0L) { XrNative.nativeSetPassthroughEnabled(xrSessionHandle, passthroughEnabled) @@ -387,6 +422,8 @@ class ImmersiveXrActivity : androidx.activity.ComponentActivity() { container.putExtra(EXTRA_QUAD_DISTANCE, quadDistance.toString()) container.putExtra(EXTRA_QUAD_SCALE, quadScale.toString()) container.putExtra(EXTRA_PASSTHROUGH_ENABLED, passthroughEnabled.toString()) + container.putExtra(EXTRA_WINDOWS_VR_ENABLED, windowsVrEnabled.toString()) + container.putExtra(EXTRA_WINDOWS_VR_OPEN_COMPOSITE, openCompositeEnabled.toString()) container.saveData() } } @@ -446,6 +483,8 @@ class ImmersiveXrActivity : androidx.activity.ComponentActivity() { override fun onDestroy() { stopXrSession() + windowsVrRuntimeService?.close() + windowsVrRuntimeService = null PluviaApp.shutdownEnvironment() super.onDestroy() } @@ -481,6 +520,7 @@ class ImmersiveXrActivity : androidx.activity.ComponentActivity() { } applyQuadTransform() + windowsVrRuntimeService?.attachSession(xrSessionHandle) XrNative.nativeSetPassthroughEnabled(xrSessionHandle, passthroughEnabled) startControllerPollingLoop() @@ -503,6 +543,13 @@ class ImmersiveXrActivity : androidx.activity.ComponentActivity() { cachedBridge = XrGamepadBridge(winHandler) } val quickMenuClicked = XrNative.nativePollSnapshot(xrSessionHandle, buttons, axes, handPoses, flags) + val stereoActive = XrNative.nativeIsWindowsStereoActive(xrSessionHandle) + if (stereoActive != flatPresentationSuspended) { + flatPresentationSuspended = stereoActive + windowsVrStatus = if (stereoActive) "Stereo active" else if (windowsVrEnabled) "Flat fallback" else "Disabled" + windowsVrRuntimeService?.onPresentationState(windowsVrStatus) + runOnUiThread { applyFlatPresentationGate(!stereoActive) } + } if (flags[2] != lastPushedStartHeld) { lastPushedStartHeld = flags[2] val setter = quickMenuSetStartHeld @@ -1115,22 +1162,48 @@ class ImmersiveXrActivity : androidx.activity.ComponentActivity() { } private fun teardownDirectRenderBridge() { + val renderer = bridgedRenderer bridgedRenderer = null directVulkanBridge = null - (PluviaApp.xServerView?.renderer as? com.winlator.renderer.VulkanRenderer)?.setVulkanXrFrameBridge(null) + (renderer as? com.winlator.renderer.VulkanRenderer)?.setVulkanXrFrameBridge(null) val bridge = directGLBridge if (bridge != null) { directGLBridge = null - (PluviaApp.xServerView?.renderer as? GLRenderer)?.setXrFrameBridge(null) + (renderer as? GLRenderer)?.setXrFrameBridge(null) PluviaApp.xServerView?.queueEvent { bridge.release() } } directRenderActive = false } + private fun applyFlatPresentationGate(enabled: Boolean) { + val xServerView = PluviaApp.xServerView + val renderer = xServerView?.renderer + xServerView?.getxServer()?.setFlatPresentationEnabled(enabled) + (renderer as? GLRenderer)?.setFlatPresentationEnabled(enabled) + (renderer as? com.winlator.renderer.VulkanRenderer)?.setFlatPresentationEnabled(enabled) + if (!enabled) { + teardownDirectRenderBridge() + gameCaptureBitmap = null + finalFrameBitmap = null + } + Timber.i( + "Immersive: flat presentation enabled=%s presentCopies=%s rendererUpdates=%s capture=%s", + enabled, + if (enabled) "active" else "suspended", + if (enabled) "active" else "suspended", + if (enabled) "fallback-ready" else "released", + ) + } + private fun scheduleNextCapture() { if (!captureActive.get()) return val handler = captureHandler ?: return + if (flatPresentationSuspended) { + handler.postDelayed({ scheduleNextCapture() }, CAPTURE_RETRY_DELAY_MS) + return + } + setupDirectRenderBridgeIfSupported() val surfaceView = PluviaApp.xServerView as? SurfaceView @@ -1179,7 +1252,7 @@ class ImmersiveXrActivity : androidx.activity.ComponentActivity() { val captureStartTime = android.os.SystemClock.uptimeMillis() try { PixelCopy.request(surfaceView, bitmap, { result -> - if (result == PixelCopy.SUCCESS) { + if (result == PixelCopy.SUCCESS && !flatPresentationSuspended) { compositeGameFrame(width, height) } val elapsed = android.os.SystemClock.uptimeMillis() - captureStartTime @@ -1195,7 +1268,7 @@ class ImmersiveXrActivity : androidx.activity.ComponentActivity() { /** Composites the game frame with the cached overlay on the capture thread. Runs only when * not direct-rendering (see scheduleNextCapture). */ private fun compositeGameFrame(width: Int, height: Int) { - if (!captureActive.get() || xrSessionHandle == 0L) return + if (!captureActive.get() || flatPresentationSuspended || xrSessionHandle == 0L) return val gameFrame = gameCaptureBitmap ?: return val finalBitmap = finalFrameBitmap?.takeIf { it.width == width && it.height == height } @@ -1215,10 +1288,10 @@ class ImmersiveXrActivity : androidx.activity.ComponentActivity() { /** Slow path: re-renders just the Compose overlay (transparent where the game is) into * [overlayLayerBitmap], on its own throttled timer, on the UI thread (required for * View.draw). Self-chaining like the capture loop, independent of it. */ - private fun scheduleNextOverlayRefresh() { + private fun scheduleNextOverlayRefresh(delayMs: Long = OVERLAY_REFRESH_INTERVAL_MS) { if (!captureActive.get()) return val handler = captureHandler ?: return - handler.postDelayed({ refreshOverlayLayer() }, OVERLAY_REFRESH_INTERVAL_MS) + handler.postDelayed({ refreshOverlayLayer() }, delayMs) } private fun refreshOverlayLayer() { @@ -1237,6 +1310,7 @@ class ImmersiveXrActivity : androidx.activity.ComponentActivity() { val hasOverlayContent = quickMenuVisible || overlayPausedUi || showControlsOnboarding || xrPointerModeActive || bootingSplashVisible + if (xrSessionHandle != 0L) XrNative.nativeSetWindowsOverlayVisible(xrSessionHandle, hasOverlayContent) val now = android.os.SystemClock.uptimeMillis() if (hasOverlayContent) { overlayContentLastVisibleAt = now @@ -1245,7 +1319,7 @@ class ImmersiveXrActivity : androidx.activity.ComponentActivity() { // Fade-outs and the mode indicator outlive their flag, so keep drawing for a grace window. if (!hasOverlayContent && now - overlayContentLastVisibleAt > OVERLAY_CONTENT_GRACE_MS) { if (overlayClearSubmitted) { - scheduleNextOverlayRefresh() + scheduleNextOverlayRefresh(OVERLAY_IDLE_REFRESH_INTERVAL_MS) return@runOnUiThread } overlayClearSubmitted = true @@ -1258,7 +1332,7 @@ class ImmersiveXrActivity : androidx.activity.ComponentActivity() { XrNative.nativeSubmitFrame(xrSessionHandle, bitmap) } } - scheduleNextOverlayRefresh() + scheduleNextOverlayRefresh(OVERLAY_IDLE_REFRESH_INTERVAL_MS) return@runOnUiThread } @@ -1325,7 +1399,10 @@ class ImmersiveXrActivity : androidx.activity.ComponentActivity() { pollingThread = null stopFrameCaptureLoop() teardownDirectRenderBridge() + flatPresentationSuspended = false + applyFlatPresentationGate(true) if (xrSessionHandle != 0L) { + windowsVrRuntimeService?.detachSession() XrNative.nativeRequestStop(xrSessionHandle) XrNative.nativeJoinAndDestroy(xrSessionHandle) xrSessionHandle = 0L diff --git a/app/src/main/java/app/gamenative/ui/screen/xr/XrNative.kt b/app/src/main/java/app/gamenative/ui/screen/xr/XrNative.kt index 8b2dda125a..c1df4f0170 100644 --- a/app/src/main/java/app/gamenative/ui/screen/xr/XrNative.kt +++ b/app/src/main/java/app/gamenative/ui/screen/xr/XrNative.kt @@ -45,6 +45,28 @@ object XrNative { outFlags: BooleanArray, ): Boolean + external fun nativeWaitWindowsFrame( + handle: Long, + afterSerial: Long, + timeoutMs: Int, + outTiming: LongArray, + outViews: FloatArray, + outInput: FloatArray, + outFlags: IntArray, + ): Boolean + + external fun nativeIsWindowsStereoActive(handle: Long): Boolean + + external fun nativeApplyWindowsHaptic( + handle: Long, + hand: Int, + amplitude: Float, + duration: Long, + frequency: Float, + ): Boolean + + external fun nativeSetWindowsOverlayVisible(handle: Long, visible: Boolean) + /** * Hands off one PixelCopy'd frame of the game's actual rendered output (ARGB_8888) to be * drawn into the immersive quad layer. See ImmersiveXrActivity's capture loop. diff --git a/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrControlServer.kt b/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrControlServer.kt new file mode 100644 index 0000000000..d53d4750cd --- /dev/null +++ b/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrControlServer.kt @@ -0,0 +1,250 @@ +package app.gamenative.ui.screen.xr.windows + +import java.io.BufferedWriter +import java.io.Closeable +import java.io.InputStream +import java.io.OutputStreamWriter +import java.net.InetAddress +import java.net.ServerSocket +import java.net.Socket +import java.util.concurrent.Executors +import java.util.concurrent.Semaphore +import java.util.concurrent.atomic.AtomicBoolean + +class WindowsVrControlServer( + private val config: WindowsVrRuntimeConfig, + private val diagnostics: WindowsVrDiagnostics, + private val snapshots: WindowsVrSnapshotProvider, +) : Closeable { + private val running = AtomicBoolean(false) + private val clients = Semaphore(4) + private val executor = Executors.newFixedThreadPool(5) + private var serverSocket: ServerSocket? = null + private var lastFrameSerial = 0L + private var firstFrameRecorded = false + private var trackingSpaceRecorded = false + + fun start() { + if (!running.compareAndSet(false, true)) return + val socket = ServerSocket(config.controlPort, 4, InetAddress.getByName("127.0.0.1")) + socket.reuseAddress = true + serverSocket = socket + executor.execute { + while (running.get()) { + val client = runCatching { socket.accept() }.getOrNull() ?: break + if (!clients.tryAcquire()) { + client.close() + } else { + executor.execute { handle(client) } + } + } + } + diagnostics.record("control", "listening=127.0.0.1:${config.controlPort}") + } + + private fun handle(socket: Socket) { + try { + socket.tcpNoDelay = true + socket.soTimeout = 15000 + val input = socket.getInputStream() + val writer = BufferedWriter(OutputStreamWriter(socket.getOutputStream(), Charsets.US_ASCII), 1024) + var requests = 0 + var greeted = false + while (running.get() && requests++ < 1024) { + val line = readBoundedLine(input) ?: break + if (!greeted && line != "HELLO") break + val response = respond(line) + if (!greeted) greeted = response == "OK GameNativeVR ${config.protocolVersion}" + writer.write(response) + writer.newLine() + writer.flush() + if (line == "BYE") break + } + } catch (error: Exception) { + diagnostics.record("control-client", error.javaClass.simpleName) + } finally { + runCatching { socket.close() } + clients.release() + } + } + + private fun readBoundedLine(input: InputStream): String? { + val bytes = ByteArray(1024) + var length = 0 + while (true) { + val value = input.read() + if (value < 0) return null + if (value == 10) return bytes.decodeToString(0, length) + if (value !in 32..126 || length == bytes.size) return null + bytes[length++] = value.toByte() + } + } + + private fun respond(line: String): String { + val tokens = line.trim().split(' ').filter { it.isNotEmpty() } + if (tokens.isEmpty()) return "ERROR malformed" + return when (tokens[0]) { + "HELLO" -> if (tokens.size == 1) "OK GameNativeVR ${config.protocolVersion}" else "ERROR malformed" + "GET_SYSTEM" -> if (tokens.size == 1) "OK system=1 vendor=2833 name=Meta_Quest_GameNative" else "ERROR malformed" + "GET_VIEWS" -> if (tokens.size == 1) getViews() else "ERROR malformed" + "GET_BOUNDS" -> if (tokens.size == 1) getBounds() else "ERROR malformed" + "WAIT_FRAME" -> if (tokens.size == 1) waitFrame() else "ERROR malformed" + "LOCATE_VIEWS" -> if (tokens.size == 1) locateViews() else "ERROR malformed" + "GET_INPUT" -> getInput(tokens) + "HAPTIC" -> haptic(tokens) + "BEGIN_SESSION" -> if (tokens.size == 1) { + diagnostics.record("session", "began") + "OK" + } else "ERROR malformed" + "END_SESSION", "REQUEST_EXIT", "BEGIN_FRAME" -> if (tokens.size == 1) "OK" else "ERROR malformed" + "END_FRAME" -> run { + val layers = tokens.singleOrNull { it.startsWith("layers=") }?.substringAfter('=')?.toIntOrNull() + if (tokens.size != 2 || layers !in 0..16) "ERROR malformed" else { + if (!firstFrameRecorded) { + firstFrameRecorded = true + diagnostics.record("frame", "first-end layers=$layers") + } + "OK" + } + } + "STATUS" -> if (tokens.size == 1) "OK ${diagnostics.compactStatus().replace(' ', '_').take(768)}" else "ERROR malformed" + "SWAPCHAIN_CREATE" -> validateSwapchainCreate(tokens) + "SWAPCHAIN_DESTROY", "SWAPCHAIN_RESET", "BYE" -> if (tokens.size == 1) "OK" else "ERROR malformed" + "GFX_API" -> if (tokens.size == 2 && tokens[1] in setOf("d3d11", "d3d12", "vulkan")) { + diagnostics.record("graphics", "api=${tokens[1]}") + "OK" + } else "ERROR unsupported" + else -> "ERROR unsupported" + } + } + + private fun validateSwapchainCreate(tokens: List): String { + if (tokens.size == 2 && tokens[1].startsWith("images=")) { + val count = tokens[1].substringAfter('=').toIntOrNull() ?: return "ERROR malformed" + if (count !in 1..8) return "ERROR malformed" + diagnostics.record("swapchain", "create images=$count") + return "OK" + } + if (tokens.size != 5) return "ERROR malformed" + val values = tokens.drop(1).associate { token -> + val separator = token.indexOf('=') + if (separator <= 0 || separator == token.lastIndex) return "ERROR malformed" + token.substring(0, separator) to token.substring(separator + 1) + } + if (values.keys != setOf("w", "h", "count", "format")) return "ERROR malformed" + val width = values["w"]?.toIntOrNull() ?: return "ERROR malformed" + val height = values["h"]?.toIntOrNull() ?: return "ERROR malformed" + val count = values["count"]?.toIntOrNull() ?: return "ERROR malformed" + if (values["format"]?.toLongOrNull() == null || width !in 1..8192 || height !in 1..8192 || count !in 1..4) { + return "ERROR malformed" + } + diagnostics.record("swapchain", "create width=$width height=$height count=$count") + return "OK" + } + + private fun waitFrame(): String { + val snapshot = snapshots.waitFrame(lastFrameSerial, 1000) ?: return "ERROR timeout" + lastFrameSerial = snapshot.timing[0] + if (!trackingSpaceRecorded) { + trackingSpaceRecorded = true + diagnostics.record( + "tracking", + "guestSpace=${if (snapshot.timing[10] != 0L) "STAGE" else "LOCAL-fallback"} " + + "bounds=${if (snapshot.timing[7] != 0L) "${snapshot.timing[8]}x${snapshot.timing[9]}um" else "unavailable"}", + ) + } + return "OK serial=${snapshot.timing[0]} time=${snapshot.timing[1]} period=${snapshot.timing[2]} shouldRender=${snapshot.timing[4]} state=${snapshot.timing[3]} render=${snapshot.timing[4]}" + } + + private fun currentSnapshot(): WindowsVrRuntimeSnapshot? { + return snapshots.latest() ?: snapshots.waitFrame(0, 1000)?.also { lastFrameSerial = it.timing[0] } + } + + private fun getViews(): String { + val snapshot = currentSnapshot() ?: return "ERROR unavailable" + return "OK count=2 width=${snapshot.timing[5]} height=${snapshot.timing[6]}" + } + + private fun getBounds(): String { + val snapshot = currentSnapshot() ?: return "ERROR unavailable" + return "OK available=${snapshot.timing[7]} width=${snapshot.timing[8]} height=${snapshot.timing[9]} supported=${snapshot.timing[10]}" + } + + private fun locateViews(): String { + val snapshot = snapshots.latest() ?: return "ERROR unavailable" + val rawValues = buildList(22) { + for (eye in 0 until 2) { + for (field in 0 until 11) { + add((snapshot.views[eye * 11 + field] * 1_000_000f).toLong()) + } + } + }.joinToString(" ") + val namedValues = buildList(22) { + for (eye in 0 until 2) { + val prefix = if (eye == 0) "l" else "r" + for (field in viewFields.indices) { + add("$prefix${viewFields[field]}=${(snapshot.views[eye * 11 + field] * 1_000_000f).toLong()}") + } + } + }.joinToString(" ") + return "OK flags=${snapshot.flags[0]} $rawValues $namedValues" + } + + private fun getInput(tokens: List): String { + if (tokens.size != 2 || tokens[1] !in setOf("hand=0", "hand=1")) return "ERROR malformed" + val snapshot = snapshots.latest() ?: return "ERROR unavailable" + val hand = tokens[1].last().digitToInt() + val base = hand * 18 + val rawValues = (0 until 18).joinToString(" ") { field -> + (snapshot.input[base + field] * 1_000_000f).toLong().toString() + } + val namedValues = inputFields.indices.joinToString(" ") { field -> + "${inputFields[field]}=${(snapshot.input[base + field] * 1_000_000f).toLong()}" + } + val active = (snapshot.flags[2] shr hand) and 1 + return "OK active=$active buttons=${snapshot.flags[1]} $rawValues $namedValues" + } + + private fun haptic(tokens: List): String { + if (tokens.size != 5) return "ERROR malformed" + val values = tokens.drop(1).associate { token -> + val separator = token.indexOf('=') + if (separator <= 0 || separator == token.lastIndex) return "ERROR malformed" + token.substring(0, separator) to token.substring(separator + 1) + } + if (values.keys != setOf("hand", "amp", "dur", "freq")) return "ERROR malformed" + val hand = values["hand"]?.toIntOrNull() ?: return "ERROR malformed" + val amplitude = values["amp"]?.toIntOrNull() ?: return "ERROR malformed" + val duration = values["dur"]?.toLongOrNull() ?: return "ERROR malformed" + val frequency = values["freq"]?.toIntOrNull() ?: return "ERROR malformed" + if (hand !in 0..1 || amplitude !in 0..1_000_000 || duration !in 0..5_000_000_000L || + frequency !in 0..1_000_000_000) return "ERROR malformed" + return if (snapshots.applyHaptic( + hand, + amplitude / 1_000_000f, + duration, + frequency / 1_000_000f, + )) { + diagnostics.record("haptic", "hand=$hand") + "OK" + } else { + diagnostics.record("haptic", "unavailable hand=$hand") + "ERROR unavailable" + } + } + + override fun close() { + if (!running.compareAndSet(true, false)) return + runCatching { serverSocket?.close() } + executor.shutdownNow() + diagnostics.record("control", "stopped") + } + + private companion object { + val viewFields = arrayOf("qx", "qy", "qz", "qw", "px", "py", "pz", "fl", "fr", "fu", "fd") + val inputFields = arrayOf( + "tr", "sq", "sx", "sy", "gqx", "gqy", "gqz", "gqw", "gpx", "gpy", "gpz", + "aqx", "aqy", "aqz", "aqw", "apx", "apy", "apz", + ) + } +} diff --git a/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrDiagnostics.kt b/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrDiagnostics.kt new file mode 100644 index 0000000000..5587d60130 --- /dev/null +++ b/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrDiagnostics.kt @@ -0,0 +1,71 @@ +package app.gamenative.ui.screen.xr.windows + +import android.content.Context +import android.os.Process +import java.io.File +import java.text.SimpleDateFormat +import java.util.ArrayDeque +import java.util.Date +import java.util.Locale + +class WindowsVrDiagnostics(context: Context, private val capacity: Int = 512) { + private val entries = ArrayDeque(capacity) + private val file = File( + context.getExternalFilesDir(null) ?: context.filesDir, + "gamenativevr/launch.log", + ).apply { parentFile?.mkdirs() } + + @Synchronized + fun begin(appId: String, executable: String, arguments: String) { + trimIfNeeded() + file.appendText( + buildString { + appendLine() + appendLine("===== GameNativeVR immersive launch ${timestamp()} =====") + appendLine("pid=${Process.myPid()} appId=$appId") + appendLine("executable=${executable.ifBlank { "" }}") + appendLine("arguments=${arguments.ifBlank { "" }}") + }, + ) + } + + @Synchronized + fun record(stage: String, value: String) { + if (entries.size == capacity) entries.removeFirst() + val entry = "${timestamp()} $stage $value" + entries.addLast(entry) + trimIfNeeded() + file.appendText("$entry\n") + } + + @Synchronized + fun recordFileTail(label: String, source: File, maxChars: Int = 12_000) { + val tail = runCatching { + source.takeIf(File::isFile)?.readText()?.takeLast(maxChars) + }.getOrNull() + record( + "diagnostics", + if (tail.isNullOrBlank()) { + "$label is unavailable at ${source.absolutePath}" + } else { + "$label tail (${source.absolutePath}):\n$tail" + }, + ) + } + + @Synchronized + fun snapshot(): List = entries.toList() + + @Synchronized + fun compactStatus(): String = entries.lastOrNull() ?: "idle" + + fun logFile(): File = file + + private fun trimIfNeeded() { + if (!file.isFile || file.length() <= 512 * 1024L) return + file.writeText("[older GameNativeVR diagnostics trimmed]\n${file.readText().takeLast(256 * 1024)}") + } + + private fun timestamp(): String = + SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS", Locale.ROOT).format(Date()) +} diff --git a/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrEmulationDiagnostics.kt b/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrEmulationDiagnostics.kt new file mode 100644 index 0000000000..a2a9925e54 --- /dev/null +++ b/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrEmulationDiagnostics.kt @@ -0,0 +1,75 @@ +package app.gamenative.ui.screen.xr.windows + +import com.winlator.container.Container +import org.json.JSONObject + +object WindowsVrEmulationDiagnostics { + private val keys = listOf( + "graphicsDriver", + "graphicsDriverVersion", + "graphicsDriverConfig", + "dxwrapper", + "dxwrapperConfig", + "displayRendererMode", + "containerVariant", + "wineVersion", + "wow64Mode", + "emulator", + "fexcoreVersion", + "fexcorePreset", + "box64Version", + "box64Preset", + "box86Version", + "box86Preset", + "cpuList", + "cpuListWoW64", + "startupSelection", + "steamType", + ) + + fun snapshot(container: Container): String { + val configFile = container.configFile + val persisted = runCatching { JSONObject(configFile.readText()) }.getOrNull() + return buildString { + appendLine("GameNativeVR emulation settings at immersive start:") + appendLine( + " configFile=${configFile.absolutePath} exists=${configFile.isFile} " + + "bytes=${if (configFile.isFile) configFile.length() else 0} " + + "modified=${if (configFile.isFile) configFile.lastModified() else 0}", + ) + appendLine(" saved: ${keys.joinToString(" ") { "$it=${persisted.value(it)}" }}") + appendLine(" loaded: ${loaded(container)}") + }.trimEnd() + } + + fun effective(container: Container): String = + "wine=${container.wineVersion} graphics=${container.graphicsDriver} " + + "graphicsConfig=${container.graphicsDriverConfig.clean()} wrapper=${container.dxWrapper} " + + "wrapperConfig=${container.dxWrapperConfig.clean()} variant=${container.containerVariant} " + + "wow64=${container.isWoW64Mode} emulator=${container.emulator} " + + "fex=${container.fexCoreVersion}/${container.fexCorePreset} " + + "box64=${container.box64Version}/${container.box64Preset} " + + "box86=${container.box86Version}/${container.box86Preset} " + + "cpu=${container.cpuList} wow64Cpu=${container.cpuListWoW64} " + + "startup=${container.startupSelection} steam=${container.steamType} args=${container.execArgs.clean()}" + + private fun loaded(container: Container): String = + "graphicsDriver=${container.graphicsDriver} graphicsDriverVersion=${container.graphicsDriverVersion} " + + "graphicsDriverConfig=${container.graphicsDriverConfig.clean()} dxwrapper=${container.dxWrapper} " + + "dxwrapperConfig=${container.dxWrapperConfig.clean()} displayRendererMode=${container.displayRenderer} " + + "containerVariant=${container.containerVariant} wineVersion=${container.wineVersion} " + + "wow64Mode=${container.isWoW64Mode} emulator=${container.emulator} " + + "fexcoreVersion=${container.fexCoreVersion} fexcorePreset=${container.fexCorePreset} " + + "box64Version=${container.box64Version} box64Preset=${container.box64Preset} " + + "box86Version=${container.box86Version} box86Preset=${container.box86Preset} " + + "cpuList=${container.cpuList} cpuListWoW64=${container.cpuListWoW64} " + + "startupSelection=${container.startupSelection} steamType=${container.steamType}" + + private fun String.clean(): String = replace('\n', ' ').replace('\r', ' ') + + private fun JSONObject?.value(key: String): String { + if (this == null) return "" + if (!has(key) || isNull(key)) return "" + return opt(key)?.toString()?.clean() ?: "" + } +} diff --git a/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrPayloadManager.kt b/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrPayloadManager.kt new file mode 100644 index 0000000000..5b79ea1d8c --- /dev/null +++ b/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrPayloadManager.kt @@ -0,0 +1,329 @@ +package app.gamenative.ui.screen.xr.windows + +import android.content.Context +import com.winlator.container.Container +import com.winlator.xenvironment.ImageFs +import java.io.File +import java.io.FileOutputStream +import java.nio.file.Files +import java.nio.file.StandardCopyOption +import java.security.MessageDigest +import java.util.Base64 + +class WindowsVrPayloadManager( + private val context: Context, + private val diagnostics: WindowsVrDiagnostics, +) { + data class PreparedPayload(val prefixDirectory: File, val manifest: File) + private data class RegistryMutation(val registry: File, val backup: File, val missing: File) + private data class FileMutation(val target: File, val backup: File, val missing: File, val targetRecord: File) + private val registryMutations = mutableListOf() + private val fileMutations = mutableListOf() + private val openCompositeDirectories = mutableListOf() + private var openCompositeRecord: File? = null + private var activeMarker: File? = null + + fun prepare(container: Container): PreparedPayload { + val prefixDirectory = File(container.rootDir, ".wine/drive_c/gamenative-xr") + check(prefixDirectory.exists() || prefixDirectory.mkdirs()) + recoverRegistry(container, prefixDirectory) + recoverSharedPayload(prefixDirectory) + recoverOpenComposite(container, prefixDirectory) + val runtime64 = File(prefixDirectory, "gamenative_openxr_runtime64.dll") + val runtime32 = File(prefixDirectory, "gamenative_openxr_runtime32.dll") + copyAssetIfChanged("gamenative_openxr_runtime64.dll", runtime64) + copyAssetIfChanged("gamenative_openxr_runtime32.dll", runtime32) + installSharedFile( + "gamenative_openxr_runtime64.dll", + File(container.rootDir, ".wine/drive_c/windows/system32/gamenative_openxr.dll"), + prefixDirectory, + "runtime64", + ) + installSharedFile( + "gamenative_openxr_runtime32.dll", + File(container.rootDir, ".wine/drive_c/windows/syswow64/gamenative_openxr.dll"), + prefixDirectory, + "runtime32", + ) + val winePath = ImageFs.find(context).winePath + val bridge = File(winePath, "lib/wine/aarch64-windows/gamenative_xr_unixbridge.dll") + check(bridge.parentFile?.exists() == true || bridge.parentFile?.mkdirs() == true) + installSharedFile("gamenative_xr_unixbridge.dll", bridge, prefixDirectory, "bridge") + val prefixBridge = File(container.rootDir, ".wine/drive_c/windows/system32/gamenative_xr_unixbridge.dll") + installSharedFile("gamenative_xr_unixbridge.dll", prefixBridge, prefixDirectory, "bridgePrefix") + val bridge32 = File(winePath, "lib/wine/i386-windows/gamenative_xr_unixbridge.dll") + installSharedFile("gamenative_xr_unixbridge32.dll", bridge32, prefixDirectory, "bridge32") + val prefixBridge32 = File(container.rootDir, ".wine/drive_c/windows/syswow64/gamenative_xr_unixbridge.dll") + installSharedFile("gamenative_xr_unixbridge32.dll", prefixBridge32, prefixDirectory, "bridge32Prefix") + val unixlib = File(winePath, "lib/wine/aarch64-unix/gamenative_xr_unixbridge.so") + check(unixlib.parentFile?.exists() == true || unixlib.parentFile?.mkdirs() == true) + installSharedFile("gamenative_xr_unixbridge.so", unixlib, prefixDirectory, "unixlib") + val manifest = File(prefixDirectory, "active_runtime.json") + val manifest64 = File(prefixDirectory, "active_runtime64.json") + val manifest32 = File(prefixDirectory, "active_runtime32.json") + val commonJson = "{\"file_format_version\":\"1.0.0\",\"runtime\":{\"library_path\":\"C:\\\\windows\\\\system32\\\\gamenative_openxr.dll\",\"name\":\"GameNative Windows OpenXR\"}}" + val json64 = "{\"file_format_version\":\"1.0.0\",\"runtime\":{\"library_path\":\"C:\\\\gamenative-xr\\\\gamenative_openxr_runtime64.dll\",\"name\":\"GameNative Windows OpenXR\"}}" + val json32 = "{\"file_format_version\":\"1.0.0\",\"runtime\":{\"library_path\":\"C:\\\\gamenative-xr\\\\gamenative_openxr_runtime32.dll\",\"name\":\"GameNative Windows OpenXR\"}}" + writeIfChanged(manifest, commonJson.toByteArray()) + writeIfChanged(manifest64, json64.toByteArray()) + writeIfChanged(manifest32, json32.toByteArray()) + val marker = File(prefixDirectory, "payload.version") + copyAssetIfChanged("payload.version", marker) + installRegistry(container, prefixDirectory) + diagnostics.record("payload", "prepared path=${prefixDirectory.path} runtime64=${runtime64.length()} runtime32=${runtime32.length()} bridge64=${bridge.length()} bridge32=${bridge32.length()} unixlib=${unixlib.length()} manifest=${manifest.length()}") + return PreparedPayload(prefixDirectory, manifest) + } + + fun installOpenComposite(container: Container) { + val gameRoot = Container.drivesIterator(container.drives).asSequence() + .firstOrNull { it[0].equals("A", ignoreCase = true) } + ?.get(1) + ?.let(::File) + ?.canonicalFile + ?: error("OpenComposite requires the launched game's A: drive") + check(gameRoot.isDirectory) + val candidates = gameRoot.walkTopDown() + .onEnter { it.canonicalFile.path.startsWith(gameRoot.path + File.separator) || it.canonicalFile == gameRoot } + .take(20001) + .toList() + check(candidates.size <= 20000) { "OpenComposite scan exceeded 20000 files" } + val targets = candidates.filter { it.isFile && it.name.equals("openvr_api.dll", ignoreCase = true) } + check(targets.isNotEmpty()) { "No openvr_api.dll was found under the launched game" } + val adapter = context.assets.open("opencomposite_x64.dll").use { it.readBytes() } + val record = File(File(container.rootDir, ".wine/drive_c/gamenative-xr"), "opencomposite.targets") + val encodedTargets = targets.map { checkNotNull(it.parentFile).canonicalPath } + .distinct() + .joinToString("\n") { Base64.getUrlEncoder().withoutPadding().encodeToString(it.toByteArray()) } + writeIfChanged(record, encodedTargets.toByteArray()) + openCompositeRecord = record + targets.forEach { target -> + check(peMachine(target.readBytes()) == 0x8664) { "OpenVR library is not x64: ${target.path}" } + val directory = checkNotNull(target.parentFile).canonicalFile + val backup = File(directory, "openvr_api.dll.gamenative-original") + val owner = File(directory, "openvr_api.dll.gamenative-owner") + val ini = File(directory, "opencomposite.ini") + val iniBackup = File(directory, "opencomposite.ini.gamenative-original") + val iniMissing = File(directory, "opencomposite.ini.gamenative-missing") + check(!backup.exists() && !owner.exists()) + writeIfChanged(backup, target.readBytes()) + if (ini.isFile) writeIfChanged(iniBackup, ini.readBytes()) else writeIfChanged(iniMissing, byteArrayOf(1)) + writeIfChanged(owner, "2\n".toByteArray()) + writeIfChanged(target, adapter) + writeIfChanged(ini, "enableAudio=false\nlogEnabled=true\n".toByteArray()) + openCompositeDirectories += directory + diagnostics.record("opencomposite", "installed path=${target.path}") + } + } + + fun restore() { + registryMutations.asReversed().forEach { mutation -> + when { + mutation.backup.isFile -> { + atomicReplace(mutation.backup, mutation.registry) + } + mutation.missing.isFile -> mutation.registry.delete() + } + mutation.backup.delete() + mutation.missing.delete() + } + registryMutations.clear() + fileMutations.asReversed().forEach { mutation -> + when { + mutation.backup.isFile -> atomicReplace(mutation.backup, mutation.target) + mutation.missing.isFile -> mutation.target.delete() + } + mutation.backup.delete() + mutation.missing.delete() + mutation.targetRecord.delete() + } + fileMutations.clear() + openCompositeDirectories.asReversed().forEach(::restoreOpenCompositeDirectory) + openCompositeDirectories.clear() + openCompositeRecord?.delete() + openCompositeRecord = null + activeMarker?.delete() + activeMarker = null + diagnostics.record("payload", "restored") + } + + private fun recoverRegistry(container: Container, payloadDirectory: File) { + listOf("system.reg", "user.reg").forEach { name -> + val registry = File(container.rootDir, ".wine/$name") + val backup = File(payloadDirectory, "$name.backup") + val missing = File(payloadDirectory, "$name.missing") + when { + backup.isFile -> atomicReplace(backup, registry) + missing.isFile -> registry.delete() + } + backup.delete() + missing.delete() + } + File(payloadDirectory, "registry.active").delete() + } + + private fun installRegistry(container: Container, payloadDirectory: File) { + val runtimePath64 = "C:\\\\gamenative-xr\\\\active_runtime64.json" + val runtimePath32 = "C:\\\\gamenative-xr\\\\active_runtime32.json" + val sections = """ + +[Software\\Khronos\\OpenXR\\1] +"ActiveRuntime"="$runtimePath64" + +[Software\\Wow6432Node\\Khronos\\OpenXR\\1] +"ActiveRuntime"="$runtimePath32" +""".trimIndent().toByteArray() + listOf("system.reg", "user.reg").forEach { name -> + val registry = File(container.rootDir, ".wine/$name") + val backup = File(payloadDirectory, "$name.backup") + val missing = File(payloadDirectory, "$name.missing") + if (registry.isFile) { + writeIfChanged(backup, registry.readBytes()) + } else { + writeIfChanged(missing, byteArrayOf(1)) + } + val existing = if (registry.isFile) registry.readBytes() else "WINE REGISTRY Version 2\n".toByteArray() + writeIfChanged(registry, existing + sections) + registryMutations += RegistryMutation(registry, backup, missing) + } + activeMarker = File(payloadDirectory, "registry.active").also { writeIfChanged(it, "2\n".toByteArray()) } + diagnostics.record("registry", "installed views=64,32") + } + + private fun recoverSharedPayload(payloadDirectory: File) { + listOf( + "runtime64", "runtime32", "bridge", "bridgePrefix", "bridge32", "bridge32Prefix", "unixlib", + ).forEach { name -> + val backup = File(payloadDirectory, "$name.backup") + val missing = File(payloadDirectory, "$name.missing") + val targetRecord = File(payloadDirectory, "$name.target") + val target = targetRecord.takeIf { it.isFile }?.readText()?.trim()?.takeIf { it.isNotEmpty() }?.let(::File) + if (target != null) { + val canonicalTarget = target.canonicalFile + validateSharedTarget(canonicalTarget) + when { + backup.isFile -> atomicReplace(backup, canonicalTarget) + missing.isFile -> canonicalTarget.delete() + } + } + backup.delete() + missing.delete() + targetRecord.delete() + } + } + + private fun recoverOpenComposite(container: Container, payloadDirectory: File) { + val gameRoot = Container.drivesIterator(container.drives).asSequence() + .firstOrNull { it[0].equals("A", ignoreCase = true) } + ?.get(1) + ?.let(::File) + ?.canonicalFile + ?: return + if (!gameRoot.isDirectory) return + val record = File(payloadDirectory, "opencomposite.targets") + val recorded = record.takeIf { it.isFile }?.readLines().orEmpty().mapNotNull { value -> + runCatching { File(String(Base64.getUrlDecoder().decode(value))).canonicalFile }.getOrNull() + } + val discovered = gameRoot.walkTopDown() + .onEnter { it.canonicalFile.path.startsWith(gameRoot.path + File.separator) || it.canonicalFile == gameRoot } + .take(20000) + .filter { it.isFile && it.name == "openvr_api.dll.gamenative-owner" } + .mapNotNull { it.parentFile } + .toList() + (recorded + discovered).distinctBy { it.path }.filter { + it.path.startsWith(gameRoot.path + File.separator) + }.forEach(::restoreOpenCompositeDirectory) + record.delete() + } + + private fun restoreOpenCompositeDirectory(directory: File) { + val owner = File(directory, "openvr_api.dll.gamenative-owner") + if (!owner.isFile || owner.readText().trim() != "2") return + val target = File(directory, "openvr_api.dll") + val backup = File(directory, "openvr_api.dll.gamenative-original") + val ini = File(directory, "opencomposite.ini") + val iniBackup = File(directory, "opencomposite.ini.gamenative-original") + val iniMissing = File(directory, "opencomposite.ini.gamenative-missing") + if (backup.isFile) atomicReplace(backup, target) + if (iniBackup.isFile) atomicReplace(iniBackup, ini) else if (iniMissing.isFile) ini.delete() + backup.delete() + iniBackup.delete() + iniMissing.delete() + owner.delete() + diagnostics.record("opencomposite", "restored path=${target.path}") + } + + private fun installSharedFile(assetPath: String, target: File, payloadDirectory: File, name: String) { + val backup = File(payloadDirectory, "$name.backup") + val missing = File(payloadDirectory, "$name.missing") + val targetRecord = File(payloadDirectory, "$name.target") + val canonicalTarget = target.canonicalFile + validateSharedTarget(canonicalTarget) + if (canonicalTarget.isFile) writeIfChanged(backup, canonicalTarget.readBytes()) else writeIfChanged(missing, byteArrayOf(1)) + writeIfChanged(targetRecord, canonicalTarget.path.toByteArray()) + copyAssetIfChanged(assetPath, canonicalTarget) + fileMutations += FileMutation(canonicalTarget, backup, missing, targetRecord) + } + + private fun validateSharedTarget(target: File) { + val roots = listOfNotNull( + ImageFs.find(context).rootDir, + context.filesDir, + context.getExternalFilesDir(null), + ).map { it.canonicalFile } + check(roots.any { target.path.startsWith(it.path + File.separator) }) + } + + private fun copyAssetIfChanged(assetPath: String, destination: File) { + val bytes = context.assets.open(assetPath).use { it.readBytes() } + writeIfChanged(destination, bytes) + diagnostics.record("payload-file", "${destination.name} size=${bytes.size} sha256=${sha256(bytes)}") + } + + private fun writeIfChanged(destination: File, bytes: ByteArray) { + check(destination.parentFile?.exists() == true || destination.parentFile?.mkdirs() == true) + if (destination.isFile && destination.readBytes().contentEquals(bytes)) return + val temporary = File(destination.parentFile, "${destination.name}.new") + FileOutputStream(temporary).use { output -> + output.write(bytes) + output.fd.sync() + } + replaceFile(temporary, destination) + } + + private fun atomicReplace(source: File, destination: File) { + val temporary = File(destination.parentFile, "${destination.name}.restore") + source.copyTo(temporary, overwrite = true) + FileOutputStream(temporary, true).use { it.fd.sync() } + replaceFile(temporary, destination) + } + + private fun replaceFile(source: File, destination: File) { + runCatching { + Files.move( + source.toPath(), + destination.toPath(), + StandardCopyOption.ATOMIC_MOVE, + StandardCopyOption.REPLACE_EXISTING, + ) + }.getOrElse { + check(source.renameTo(destination) || run { + destination.delete() + source.renameTo(destination) + }) + } + } + + private fun sha256(bytes: ByteArray): String { + return MessageDigest.getInstance("SHA-256").digest(bytes).joinToString("") { "%02x".format(it) } + } + + private fun peMachine(bytes: ByteArray): Int { + check(bytes.size >= 256) + val offset = (bytes[0x3c].toInt() and 0xff) or + ((bytes[0x3d].toInt() and 0xff) shl 8) or + ((bytes[0x3e].toInt() and 0xff) shl 16) or + ((bytes[0x3f].toInt() and 0xff) shl 24) + check(offset >= 0x40 && offset + 6 <= bytes.size) + return (bytes[offset + 4].toInt() and 0xff) or ((bytes[offset + 5].toInt() and 0xff) shl 8) + } +} diff --git a/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrRuntimeConfig.kt b/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrRuntimeConfig.kt new file mode 100644 index 0000000000..7ccc6ba0cb --- /dev/null +++ b/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrRuntimeConfig.kt @@ -0,0 +1,22 @@ +package app.gamenative.ui.screen.xr.windows + +import com.winlator.container.Container + +data class WindowsVrRuntimeConfig( + val enabled: Boolean, + val openCompositeEnabled: Boolean, + val controlPort: Int = 38476, + val protocolVersion: Int = 2, + val runtimeDirectory: String = "C:\\gamenative-xr", + val runtimeManifest: String = "C:\\gamenative-xr\\active_runtime.json", + val transportEndpoint: String = "@gamenative-xr", +) { + companion object { + fun from(container: Container): WindowsVrRuntimeConfig { + return WindowsVrRuntimeConfig( + enabled = container.getExtra("windowsVrEnabled", "true").toBoolean(), + openCompositeEnabled = container.getExtra("windowsVrOpenCompositeEnabled", "false").toBoolean(), + ) + } + } +} diff --git a/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrRuntimeService.kt b/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrRuntimeService.kt new file mode 100644 index 0000000000..f936b34889 --- /dev/null +++ b/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrRuntimeService.kt @@ -0,0 +1,190 @@ +package app.gamenative.ui.screen.xr.windows + +import android.content.Context +import app.gamenative.CrashHandler +import com.winlator.container.Container +import com.winlator.core.ProcessHelper +import com.winlator.core.envvars.EnvVars +import java.io.Closeable +import java.io.File + +class WindowsVrRuntimeService(context: Context) : Closeable { + private val applicationContext = context.applicationContext + private val diagnostics = WindowsVrDiagnostics(applicationContext) + private val payloadManager = WindowsVrPayloadManager(applicationContext, diagnostics) + private val snapshots = WindowsVrSnapshotProvider() + private var config: WindowsVrRuntimeConfig? = null + private var controlServer: WindowsVrControlServer? = null + private var presentationState = "" + private var runtimeLogDirectory: File? = null + private var container: Container? = null + + fun beforeWineSystemSetup(container: Container) { + this.container = container + config = WindowsVrRuntimeConfig.from(container) + diagnostics.begin(container.id, container.executablePath, container.execArgs) + diagnostics.record("activity", "Immersive VR host active") + diagnostics.record("configuration", "enabled=${config?.enabled} openComposite=${config?.openCompositeEnabled}") + diagnostics.record("emulation", WindowsVrEmulationDiagnostics.snapshot(container)) + } + + fun afterContainerEnvironmentMerged(env: EnvVars, container: Container) { + this.container = container + val active = config ?: WindowsVrRuntimeConfig.from(container).also { config = it } + if (!active.enabled) return + check(container.wineVersion.contains("arm64ec", ignoreCase = true)) { + "Windows VR requires a supported ARM64EC Wine or Proton build" + } + check(container.dxWrapper.contains("dxvk", ignoreCase = true)) { + "Windows VR D3D11 requires DXVK native interop" + } + diagnostics.record("launch", "Preparing Windows OpenXR payload") + val payload = payloadManager.prepare(container) + runtimeLogDirectory = payload.prefixDirectory + listOf("runtime.log", "unix.log").forEach { payload.prefixDirectory.resolve(it).delete() } + if (active.openCompositeEnabled) payloadManager.installOpenComposite(container) + env.put("XR_RUNTIME_JSON", active.runtimeManifest) + env.put("GAMENATIVE_XR", "1") + env.put("GAMENATIVE_XR_LOG", "1") + env.put("GAMENATIVE_XR_SOCKET", active.transportEndpoint) + env.put("GAMENATIVE_XR_BRIDGE_HOST", "127.0.0.1") + env.put("GAMENATIVE_XR_BRIDGE_PORT", active.controlPort.toString()) + env.put("GAMENATIVE_XR_CONTROL", "127.0.0.1:${active.controlPort}") + env.put("GAMENATIVE_XR_TRANSPORT", active.transportEndpoint) + env.put("GAMENATIVE_XR_RUNTIME_DIR", active.runtimeDirectory) + env.put("GAMENATIVE_XR_UNIX_LOG", payload.prefixDirectory.resolve("unix.log").path) + val overrides = env.get("WINEDLLOVERRIDES").split(';') + .map(String::trim) + .filter(String::isNotEmpty) + .filterNot { + val name = it.substringBefore('=') + name.equals("gamenative_xr_unixbridge", ignoreCase = true) || + name.equals("gameoverlayrenderer", ignoreCase = true) || + name.equals("gameoverlayrenderer64", ignoreCase = true) + } + .plus("gameoverlayrenderer=n") + .plus("gameoverlayrenderer64=n") + .plus("gamenative_xr_unixbridge=b") + env.put("WINEDLLOVERRIDES", overrides.joinToString(";")) + diagnostics.record( + "environment", + "runtime=${active.runtimeManifest} transport=${active.transportEndpoint} " + + "control=127.0.0.1:${active.controlPort}", + ) + diagnostics.record("effective-launch", WindowsVrEmulationDiagnostics.effective(container)) + diagnostics.record("payload", payloadSummary(payload.prefixDirectory)) + } + + fun beforeGuestProcessStart() { + val active = config ?: return + if (!active.enabled || controlServer != null) return + controlServer = WindowsVrControlServer(active, diagnostics, snapshots).also { it.start() } + diagnostics.record("control", "listening on 127.0.0.1:${active.controlPort}") + } + + fun onEnvironmentStarted() { + diagnostics.record("environment", "Wine environment started; waiting for OpenXR") + } + + fun onPresentationState(state: String) { + if (presentationState == state) return + presentationState = state + diagnostics.record("presentation", state) + } + + fun onGuestProcessError(error: String) { + diagnostics.record("guest-error", error) + captureDiagnostics() + } + + fun status(): List = diagnostics.snapshot() + + fun exportDiagnostics(): File { + captureDiagnostics() + val directory = File(applicationContext.getExternalFilesDir(null) ?: applicationContext.filesDir, "diagnostics") + check(directory.exists() || directory.mkdirs()) + val report = File(directory, "windows-vr-${System.currentTimeMillis()}.txt") + diagnostics.record("diagnostics", "exported path=${report.path}") + report.writeText(diagnostics.logFile().takeIf(File::isFile)?.readText().orEmpty()) + return report + } + + fun attachSession(handle: Long) { + snapshots.attach(handle) + diagnostics.record("openxr", "Immersive session attached handle=$handle") + } + + fun detachSession() { + snapshots.detach() + diagnostics.record("openxr", "Immersive session detached") + } + + private fun captureDiagnostics() { + diagnostics.record("android", "app log tail:\n${CrashHandler.getAppLogs(800)}") + val active = container + if (active != null) { + val runtime = File(active.rootDir, ".wine/drive_c/gamenative-xr") + diagnostics.recordFileTail("Windows OpenXR runtime log", runtime.resolve("runtime.log")) + diagnostics.recordFileTail("Wine OpenXR Unix bridge log", runtime.resolve("unix.log")) + diagnostics.recordFileTail( + "ColdClientLoader configuration", + File(active.rootDir, ".wine/drive_c/Program Files (x86)/Steam/ColdClientLoader.ini"), + ) + val users = File(active.rootDir, ".wine/drive_c/users") + val openComposite = users.walkTopDown() + .filter { it.isFile && it.name.equals("opencomposite.log", ignoreCase = true) } + .maxByOrNull(File::lastModified) + diagnostics.recordFileTail( + "OpenComposite log", + openComposite ?: File(users, "/AppData/Local/OpenComposite/logs/opencomposite.log"), + ) + val playerLog = users.walkTopDown() + .filter { it.isFile && it.name.equals("Player.log", ignoreCase = true) } + .maxByOrNull(File::lastModified) + diagnostics.recordFileTail( + "latest Unity Player log", + playerLog ?: File(users, "/AppData/LocalLow//Player.log"), + ) + } + val processes = runCatching { + ProcessHelper.listSubProcesses().sortedBy { it.pid }.joinToString("\n") { process -> + val command = runCatching { + File("/proc/${process.pid}/cmdline").readBytes().toString(Charsets.UTF_8) + .replace('\u0000', ' ').trim() + }.getOrDefault("") + val state = runCatching { + File("/proc/${process.pid}/status").useLines { lines -> + lines.firstOrNull { it.startsWith("State:") } + } + }.getOrNull() ?: "State: " + val wait = runCatching { File("/proc/${process.pid}/wchan").readText().trim() } + .getOrDefault("") + "pid=${process.pid} ppid=${process.ppid} rss=${process.rssBytes} " + + "name=${process.name} $state wchan=$wait cmd=$command" + } + }.getOrElse { "" } + diagnostics.record("processes", processes.ifBlank { "" }) + diagnostics.recordFileTail( + "Wine debug log", + File(applicationContext.getExternalFilesDir(null), "wine_logs/wine_debug.log"), + ) + } + + private fun payloadSummary(directory: File): String = buildString { + append("directory=${directory.path}") + directory.listFiles().orEmpty().sortedBy(File::getName).forEach { file -> + append(" ${file.name}=") + append(if (file.isFile) "file(${file.length()} bytes)" else if (file.isDirectory) "directory" else "missing") + } + } + + override fun close() { + diagnostics.record("service", "closing") + controlServer?.close() + controlServer = null + snapshots.detach() + payloadManager.restore() + runtimeLogDirectory = null + container = null + } +} diff --git a/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrSnapshotProvider.kt b/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrSnapshotProvider.kt new file mode 100644 index 0000000000..0f29a6879a --- /dev/null +++ b/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrSnapshotProvider.kt @@ -0,0 +1,56 @@ +package app.gamenative.ui.screen.xr.windows + +import app.gamenative.ui.screen.xr.XrNative + +data class WindowsVrRuntimeSnapshot( + val timing: LongArray, + val views: FloatArray, + val input: FloatArray, + val flags: IntArray, +) + +class WindowsVrSnapshotProvider { + @Volatile + private var handle = 0L + @Volatile + private var latest: WindowsVrRuntimeSnapshot? = null + + fun attach(handle: Long) { + this.handle = handle + } + + fun detach() { + handle = 0L + latest = null + } + + fun waitFrame(afterSerial: Long, timeoutMs: Int): WindowsVrRuntimeSnapshot? { + val activeHandle = handle + if (activeHandle == 0L) return null + val snapshot = WindowsVrRuntimeSnapshot(LongArray(11), FloatArray(22), FloatArray(36), IntArray(3)) + if (!XrNative.nativeWaitWindowsFrame( + activeHandle, + afterSerial, + timeoutMs, + snapshot.timing, + snapshot.views, + snapshot.input, + snapshot.flags, + )) return null + latest = snapshot + return snapshot + } + + fun latest(): WindowsVrRuntimeSnapshot? = latest + + fun applyHaptic(hand: Int, amplitude: Float, duration: Long, frequency: Float): Boolean { + val activeHandle = handle + return activeHandle != 0L && XrNative.nativeApplyWindowsHaptic( + activeHandle, + hand, + amplitude, + duration, + frequency, + ) + } +} diff --git a/app/src/main/java/app/gamenative/ui/screen/xserver/XServerScreen.kt b/app/src/main/java/app/gamenative/ui/screen/xserver/XServerScreen.kt index 6029c275ec..b1531b6ab6 100644 --- a/app/src/main/java/app/gamenative/ui/screen/xserver/XServerScreen.kt +++ b/app/src/main/java/app/gamenative/ui/screen/xserver/XServerScreen.kt @@ -2084,6 +2084,7 @@ fun XServerScreen( if (shouldShowMouseCursor()) renderer?.setCursorVisible(true) xServerState.value.winStarted = true } + if (!getxServer().isFlatPresentationEnabled) return if (frameRatingWindowId == -1 && window.isApplicationWindow()) { refreshFrameRatingTracking("content-update") } @@ -2230,6 +2231,7 @@ fun XServerScreen( Timber.i("Doing things once") val envVars = EnvVars() + immersiveHooks?.windowsVr?.beforeWineSystemSetup(container) runBlocking { setupWineSystemFiles( @@ -2275,7 +2277,8 @@ fun XServerScreen( xServerView!!.getxServer(), containerVariantChanged, onGameLaunchError, - isOffline + isOffline, + immersiveHooks, ) // Autostart performance driver after environment is set up @@ -3682,7 +3685,8 @@ private fun setupXEnvironment( xServer: XServer, containerVariantChanged: Boolean, onGameLaunchError: ((String) -> Unit)? = null, - offline: Boolean = false + offline: Boolean = false, + immersiveHooks: app.gamenative.ui.screen.xr.ImmersiveSessionHooks? = null, ): XEnvironment { ProcessHelper.hardKillStaleWineProcesses() @@ -3831,6 +3835,7 @@ private fun setupXEnvironment( guestProgramLauncherComponent.setSteamType(container.getSteamType()) envVars.putAll(container.envVars) + immersiveHooks?.windowsVr?.afterContainerEnvironmentMerged(envVars, container) envVars.remove("DXVK_FRAME_RATE") envVars.remove("VKD3D_FRAME_RATE") if (!envVars.has("WINEESYNC")) envVars.put("WINEESYNC", "1") @@ -4064,7 +4069,9 @@ private fun setupXEnvironment( } try { + immersiveHooks?.windowsVr?.beforeGuestProcessStart() environment.startEnvironmentComponents() + immersiveHooks?.windowsVr?.onEnvironmentStarted() } catch (e: Exception) { Timber.e(e, "Failed to start environment components, cleaning up") try { diff --git a/app/src/main/java/com/winlator/renderer/GLRenderer.java b/app/src/main/java/com/winlator/renderer/GLRenderer.java index f5645df8fb..2d5a9af1bd 100644 --- a/app/src/main/java/com/winlator/renderer/GLRenderer.java +++ b/app/src/main/java/com/winlator/renderer/GLRenderer.java @@ -62,6 +62,16 @@ public class GLRenderer implements GLSurfaceView.Renderer, WindowManager.OnWindo private final EffectComposer effectComposer; private FrameRating frameRating; private volatile XrFrameBridge xrFrameBridge = null; + private volatile boolean flatPresentationEnabled = true; + + public void setFlatPresentationEnabled(boolean enabled) { + if (flatPresentationEnabled == enabled) return; + flatPresentationEnabled = enabled; + if (enabled) { + xServerView.queueEvent(this::updateScene); + xServerView.requestRender(); + } + } public GLRenderer(XServerViewGL xServerView, XServer xServer) { this.xServerView = xServerView; @@ -127,6 +137,7 @@ public void onSurfaceChanged(GL10 gl, int width, int height) { @Override public void onDrawFrame(GL10 gl) { + if (!flatPresentationEnabled) return; if (toggleFullscreen) { fullscreen = !fullscreen; toggleFullscreen = false; @@ -239,29 +250,34 @@ else if (magnifierEnabled) { @Override public void onMapWindow(Window window) { + if (!flatPresentationEnabled) return; xServerView.queueEvent(this::updateScene); xServerView.requestRender(); } @Override public void onUnmapWindow(Window window) { + if (!flatPresentationEnabled) return; xServerView.queueEvent(this::updateScene); xServerView.requestRender(); } @Override public void onChangeWindowZOrder(Window window) { + if (!flatPresentationEnabled) return; xServerView.queueEvent(this::updateScene); xServerView.requestRender(); } @Override public void onUpdateWindowContent(Window window) { + if (!flatPresentationEnabled) return; xServerView.requestRender(); } @Override public void onUpdateWindowGeometry(final Window window, boolean resized) { + if (!flatPresentationEnabled) return; if (resized) { xServerView.queueEvent(this::updateScene); } @@ -271,11 +287,13 @@ public void onUpdateWindowGeometry(final Window window, boolean resized) { @Override public void onUpdateWindowAttributes(Window window, Bitmask mask) { + if (!flatPresentationEnabled) return; if (mask.isSet(WindowAttributes.FLAG_CURSOR)) xServerView.requestRender(); } @Override public void onPointerMove(short x, short y) { + if (!flatPresentationEnabled) return; xServerView.requestRender(); } @@ -355,7 +373,7 @@ public void setXrFrameBridge(XrFrameBridge xrFrameBridge) { this.xrFrameBridge = xrFrameBridge; if (xrFrameBridge == null) clearRenderTargetSizeOverride(); viewportNeedsUpdate = true; - xServerView.requestRender(); + if (flatPresentationEnabled) xServerView.requestRender(); } /** Whether active screen effects are forcing the composer path, which blocks the XR direct @@ -373,6 +391,7 @@ private Drawable createRootCursorDrawable() { } private void updateScene() { + if (!flatPresentationEnabled) return; try (XLock lock = xServer.lock(XServer.Lockable.WINDOW_MANAGER, XServer.Lockable.DRAWABLE_MANAGER)) { renderableWindows.clear(); collectRenderableWindows(xServer.windowManager.rootWindow, xServer.windowManager.rootWindow.getX(), xServer.windowManager.rootWindow.getY()); diff --git a/app/src/main/java/com/winlator/renderer/VulkanRenderer.java b/app/src/main/java/com/winlator/renderer/VulkanRenderer.java index d0781ccfac..601e2c3984 100644 --- a/app/src/main/java/com/winlator/renderer/VulkanRenderer.java +++ b/app/src/main/java/com/winlator/renderer/VulkanRenderer.java @@ -68,6 +68,18 @@ public class VulkanRenderer implements WindowManager.OnWindowModificationListene private boolean xRenderingPausedForScanout = false; private volatile VulkanXrFrameBridge xrFrameBridge = null; private volatile long xrTargetAhbPtr = 0; + private volatile boolean flatPresentationEnabled = true; + + public void setFlatPresentationEnabled(boolean enabled) { + if (flatPresentationEnabled == enabled) return; + flatPresentationEnabled = enabled; + if (!enabled) { + scenePending.set(false); + } else { + queueSceneUpdate(); + xServerView.requestRender(); + } + } /** See VulkanXrFrameBridge's kdoc — null except for the Meta Quest immersive path. */ public void setVulkanXrFrameBridge(VulkanXrFrameBridge xrFrameBridge) { @@ -174,6 +186,7 @@ private long did(Drawable d) { } public void queueSceneUpdate() { + if (!flatPresentationEnabled) return; if (scenePending.compareAndSet(false, true)) { xServerView.queueEvent(() -> { scenePending.set(false); @@ -378,6 +391,7 @@ private void updateTransform() { } public void updateScene() { + if (!flatPresentationEnabled) return; ArrayList newList = new ArrayList<>(); try (XLock xl = xServer.lock(XServer.Lockable.WINDOW_MANAGER, XServer.Lockable.DRAWABLE_MANAGER)) { collectWindows(newList, xServer.windowManager.rootWindow, @@ -478,6 +492,7 @@ private void sendCursorToNative(Cursor cursor) { } public void onUpdateWindowContentDirect(Window window, Drawable pixmap, short xOff, short yOff) { + if (!flatPresentationEnabled) return; if (hudRef != null && !nativeMode) hudRef.update(); if (nativeHandle == 0 || pixmap == null) return; Drawable targetDrawable = window.getContent(); @@ -527,6 +542,7 @@ public void onUpdateWindowContentDirect(Window window, Drawable pixmap, short xO @Override public void onUpdateWindowContent(Window window) { + if (!flatPresentationEnabled) return; if (hudRef != null) hudRef.update(); final long handle; synchronized (lock) { handle = nativeHandle; } @@ -583,6 +599,7 @@ public void onUpdateWindowContent(Window window) { @Override public void onPointerMove(short x, short y) { + if (!flatPresentationEnabled) return; synchronized (lock) { if (nativeHandle == 0) return; nativeSetPointerPos(nativeHandle, x, y); @@ -607,7 +624,9 @@ public void onDestroyWindow(Window window) { }); } - @Override public void onMapWindow(Window window) { queueSceneUpdate(); } + @Override public void onMapWindow(Window window) { + if (flatPresentationEnabled) queueSceneUpdate(); + } @Override public void onUnmapWindow(Window window) { @@ -618,15 +637,18 @@ public void onUnmapWindow(Window window) { }); } - @Override public void onChangeWindowZOrder(Window window) { queueSceneUpdate(); } + @Override public void onChangeWindowZOrder(Window window) { + if (flatPresentationEnabled) queueSceneUpdate(); + } @Override public void onUpdateWindowGeometry(Window window, boolean resized) { - queueSceneUpdate(); + if (flatPresentationEnabled) queueSceneUpdate(); } @Override public void onUpdateWindowAttributes(Window window, Bitmask mask) { + if (!flatPresentationEnabled) return; if (mask.isSet(WindowAttributes.FLAG_CURSOR)) { synchronized (lock) { Window pw = xServer.inputDeviceManager.getPointWindow(); diff --git a/app/src/main/java/com/winlator/xserver/XServer.java b/app/src/main/java/com/winlator/xserver/XServer.java index 12fd46a004..18565e8480 100644 --- a/app/src/main/java/com/winlator/xserver/XServer.java +++ b/app/src/main/java/com/winlator/xserver/XServer.java @@ -48,6 +48,7 @@ public enum Lockable {WINDOW_MANAGER, PIXMAP_MANAGER, DRAWABLE_MANAGER, GRAPHIC_ private final boolean mouseDragCompatibilityEnabled; private boolean simulateTouchScreen = false; private final boolean runningFromGlibc; + private volatile boolean flatPresentationEnabled = true; public XServer(ScreenInfo screenInfo, boolean useGlibcContainer) { this(screenInfo, useGlibcContainer, false); @@ -105,6 +106,14 @@ public void setRenderingEnabled(boolean enabled) { // intentionally empty } + public void setFlatPresentationEnabled(boolean enabled) { + flatPresentationEnabled = enabled; + } + + public boolean isFlatPresentationEnabled() { + return flatPresentationEnabled; + } + public WinHandler getWinHandler() { return winHandler; } diff --git a/app/src/main/java/com/winlator/xserver/extensions/PresentExtension.java b/app/src/main/java/com/winlator/xserver/extensions/PresentExtension.java index 5892feeba7..dd7b682a29 100644 --- a/app/src/main/java/com/winlator/xserver/extensions/PresentExtension.java +++ b/app/src/main/java/com/winlator/xserver/extensions/PresentExtension.java @@ -320,6 +320,13 @@ private void presentPixmap(XClient client, XInputStream inputStream, XOutputStre long ust = System.nanoTime() / 1000; long msc = ust / (targetFps > 0 ? (1_000_000L / targetFps) : (1_000_000L / 60)); + if (!client.xServer.isFlatPresentationEnabled()) { + sendCompleteNotify(window, serial, Kind.PIXMAP, Mode.SKIP, ust, msc); + if (targetFps > 0) scheduleIdleNotify(window, pixmap, serial, idleFence, targetFps, vr); + else sendIdleNotify(window, pixmap, serial, idleFence); + return; + } + synchronized (content.renderLock) { if (asr != null) { content.setTexture(pixmap.drawable.getTexture()); diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index c34c5719dd..d03963901c 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -331,6 +331,12 @@ Double-click a thumbstick to switch Xbox controller / XR pointer XR pointer mode Xbox controller mode + Windows VR + Enable Windows VR + OpenVR compatibility (experimental) + Runtime and compatibility changes apply on the next launch. + Export Windows VR diagnostics + Save the bounded runtime event report %1$d running, tap/click a process to close No running EXEs detected. Performance HUD diff --git a/app/src/main/windows/openxr_runtime/CMakeLists.txt b/app/src/main/windows/openxr_runtime/CMakeLists.txt new file mode 100644 index 0000000000..deab0c1f6b --- /dev/null +++ b/app/src/main/windows/openxr_runtime/CMakeLists.txt @@ -0,0 +1,30 @@ +cmake_minimum_required(VERSION 3.22) +project(gamenative_openxr_runtime C) + +include(FetchContent) +FetchContent_Declare( + openxr_sdk + URL https://github.com/KhronosGroup/OpenXR-SDK-Source/archive/refs/tags/release-1.1.61.tar.gz + URL_HASH SHA256=b88e83e2515cadb08608747b6c0f272a62b04f5089a965288f3aa4a4332291ba + DOWNLOAD_EXTRACT_TIMESTAMP TRUE +) +set(BUILD_LOADER OFF CACHE BOOL "" FORCE) +set(BUILD_API_LAYERS OFF CACHE BOOL "" FORCE) +set(BUILD_TESTS OFF CACHE BOOL "" FORCE) +set(BUILD_CONFORMANCE_TESTS OFF CACHE BOOL "" FORCE) +set(BUILD_SDK_TESTS OFF CACHE BOOL "" FORCE) +FetchContent_MakeAvailable(openxr_sdk) + +add_library(gamenative_openxr_runtime SHARED gamenative_openxr_runtime.c gamenative_control.c gamenative_actions.c gamenative_dxvk.c) +target_compile_definitions(gamenative_openxr_runtime PRIVATE XR_USE_PLATFORM_WIN32 XR_USE_GRAPHICS_API_D3D11 WIN32_LEAN_AND_MEAN) +target_include_directories(gamenative_openxr_runtime PRIVATE + ${openxr_sdk_BINARY_DIR}/include + ${openxr_sdk_SOURCE_DIR}/include + ${openxr_sdk_SOURCE_DIR}/src/common +) +target_link_libraries(gamenative_openxr_runtime PRIVATE ws2_32 dxgi) +set_target_properties(gamenative_openxr_runtime PROPERTIES OUTPUT_NAME gamenative_openxr_runtime64) +if(MSVC) + target_compile_options(gamenative_openxr_runtime PRIVATE /W4 /WX /wd4201 /guard:cf) + target_link_options(gamenative_openxr_runtime PRIVATE /DEF:${CMAKE_CURRENT_SOURCE_DIR}/gamenative_openxr_runtime_x64.def) +endif() diff --git a/app/src/main/windows/openxr_runtime/builtin/Makefile.in b/app/src/main/windows/openxr_runtime/builtin/Makefile.in new file mode 100644 index 0000000000..315a4e9aa6 --- /dev/null +++ b/app/src/main/windows/openxr_runtime/builtin/Makefile.in @@ -0,0 +1,4 @@ +MODULE = gamenative_xr_unixbridge.dll +IMPORTS = ntdll +EXTRADLLFLAGS = -marm64x -Wl,/align:65536 -Wl,--file-alignment,65536 +SOURCES = gamenative_xr_unixbridge.c diff --git a/app/src/main/windows/openxr_runtime/builtin/gamenative_xr_unixbridge.c b/app/src/main/windows/openxr_runtime/builtin/gamenative_xr_unixbridge.c new file mode 100644 index 0000000000..8b95de6173 --- /dev/null +++ b/app/src/main/windows/openxr_runtime/builtin/gamenative_xr_unixbridge.c @@ -0,0 +1,29 @@ + + + + + +typedef unsigned int gn_dword; +typedef int gn_bool; +typedef unsigned long long gn_unixlib_handle_t; +typedef int (*gn_unix_call_dispatcher_t)( + gn_unixlib_handle_t handle, unsigned int code, void *args); + +extern gn_unixlib_handle_t __wine_unixlib_handle; +extern gn_unix_call_dispatcher_t __wine_unix_call_dispatcher; +extern int __wine_init_unix_call(void); + +__declspec(dllexport) +int gnWineUnixCall(unsigned int code, void *args) +{ + return __wine_unix_call_dispatcher(__wine_unixlib_handle, code, args); +} + +gn_bool DllMain(void *instance, gn_dword reason, void *reserved) +{ + (void)instance; + (void)reserved; + if (reason == 1 ) + return __wine_init_unix_call() == 0; + return 1; +} diff --git a/app/src/main/windows/openxr_runtime/builtin/gamenative_xr_unixbridge.spec b/app/src/main/windows/openxr_runtime/builtin/gamenative_xr_unixbridge.spec new file mode 100644 index 0000000000..8f6771b7da --- /dev/null +++ b/app/src/main/windows/openxr_runtime/builtin/gamenative_xr_unixbridge.spec @@ -0,0 +1 @@ +@ stdcall gnWineUnixCall(long ptr) diff --git a/app/src/main/windows/openxr_runtime/builtin/gamenative_xr_unixbridge32.dll b/app/src/main/windows/openxr_runtime/builtin/gamenative_xr_unixbridge32.dll new file mode 100644 index 0000000000000000000000000000000000000000..54762881b3aa6f79e0d0c38c54895946e679e697 GIT binary patch literal 41706 zcmeI5ZEPGz8OP^rr(9b*IU-vPB7#$Ef{~ij*>PSd{&0@(l3221T2DHvvmlD3)d9N>$SjfXpW(1ZqE2C6y30iSi~PL?wjyP@xDFDFq9G2%kVX{?E?t z?e3jlpo)Sh&qTAc^Pgv)ndi5&Yu{ye-T#$kQ7?pOKrWYsxQ3Ea!rpGanM3o7MqZDO zO&M9s$VZcXebqgz=$IZgr}9y19yk%r6*79Psp+X!$8azuL|^DhvFFd1&WmLs-hqBk zJn`Jqp}M^yf=Uq?S@{kg2rO3btr_VS5@?F5ek4*KB)cdIaf>Q* zLi~uzjnc9Zog20J^l&`L?9g0gIG>fb8?*Fj3)N+sJWa^Wo(awTTr8tm8noS{L$K|r z^reIlt1+`+TiziZbFuBH^reJtryO1)9fEB~r7tDW64NK;xT)njX?}yqG(ReRDM5B) zr4mVD+MJ_JZJMKTbv3Tdya*fecMjQ?66DWNcJ?uuLnGOdy)Pxm&eXGov~z5h(MWc4 z$i9>i;;^sEyG(!yFaajO1egF5U;<2l2{3{GYXZwl7saxZ7Rw`xYoq7!9Y9n>2FrsD z*TZ6D;Scj`;rYvrp{X7Bci_X|mDL@uuI_ky^-tTb(MQ9(*Bi;^#Qa+GV$&}4`#wI^ zMHX8cXgk`taHh3!aWsq~ywK3PFx=Wues6vaE&sd==NR{IJ3jM|53iQXWoHglzqUUl zRR3<6wPAsGMq<^fiir* z-mcS(BA5}vEtgxm=4eK{?%r_uQ%N2;F##sP1egF5U;<2l2`~XBzyz286L{1F>cl(0 ztN5hNfC(@GCa@lXys$(@WbrTNltM`PH9XZXr}D}i@y6h*45~)cbbD+t~Vdnm;e)C0!)Aj zFaajO1egF5U;<2l2{3_2Pr!a;9d1LjLn3r39Qt%)L&LZ5VE-;?^v=1pcgtnl=GgY| zk?oB=+wlzhMt#Vh@-NWGe(Jt^d-zJ-;ihe8Z^Em3eO(vYe}(ohq7-g>a=yNB^M-A+ zk#Bk!fqYZnC#f&eR<>`!mhNw$)P@{KeiPbjB&3|V^}byH&4&4Hb(e2+-|D{IO*5r& z&LFq0mdi=M?IjflNt~Df6JP>NfC(@GCcp%k025#WOn?deuMzmqof__2-e}$jOKhr%_U}-x&}UVnWO5dCf8|>T=q&ZxWOa0I3LUq;Jf)j6Ck@k@(z5+} zu3*jx@oe3Yl|5qQGpXrf!L;NfC(@GCh*@P5F0n_|Es6Z z_Yd)QzKPJdc7gs6zA801b-G{w348xJY#Wi460`Ja%hr`rABs9{j))?b(JalW)}gEq z(PIboj-ra#SgGU+G)_IauSzl9bMy(c)rTgrr9Cgj%tFP8MyLm6G;82MUg|;)&*R+Zz;g@6KGGaYXcF4+QZ8WU`^Sg6l9w&35`3wkycBHbhpX_fRAd?pA!%Sj6W6 zdOYRyRz>Y`r|7B})|@-xfDfv~%*tuu@bTv9H>S053VADrKZT8AIE}rkbJ@8jEZebD zTrjChZd|*eZ?&E&nhmcB2F2CdLGH;;t>>!wD4WhU*G9yYvj32$JpMU%()p$4Otgc^ zonaF47B&Z0DmKBj<9hs~yCbTvQL5n)9}ACjXq~lMO@3pW1IH?H?W{!L?l^o7zFM)V z9gA!qx*Z-<>~ux(j#qHuyT`O^Ynuaf#Z`WusYKxJxUs)pu~|R%XDY)#p5snel&xY< zY;AMEs@QxMd%@(!{vF60jYT~UBK9mwBBOqCopfkWO({AQ8q2e>D#Toy`5Hf0q0m*G z-f67-yg|Jpe&r4+BI>jGJro+p>-7-IB`DtL5x5H~&(*JrNAZr%)A$8}P6W@-bMz}i zKWomV zjF2<(pi?LXuoyXQLYHG&Nf9jRX^V(ySz{uP$NrszYLm+N=GNOiT=Baxmdg5Yf%XIz z2jO*F6pnOF-M6xWoozbnt#sd?HOLxca#B5}ASHbRQWck4FI7Z}y0P!j0clRM7#fzz-k}st_q5O4UC;K~@UL1Gy5%#Ky>wI# z +#include +#include + +#define GN_PATHS 128 +#define GN_ACTION_SETS 8 +#define GN_ACTIONS 64 +#define GN_ACTION_SPACES 32 +#define GN_SET_MAGIC 0x4758415345543032ull +#define GN_ACTION_MAGIC 0x47584143544e3032ull +#define GN_SPACE_MAGIC 0x4758535041433032ull + +typedef struct gn_path_entry { char value[XR_MAX_PATH_LENGTH]; } gn_path_entry; +typedef struct gn_action_set { uint64_t magic; XrInstance owner; uint32_t attached; } gn_action_set; +typedef struct gn_action { uint64_t magic; gn_action_set *set; XrActionType type; XrPath bindings[2]; } gn_action; +typedef struct gn_action_space { uint64_t magic; XrSession owner; gn_action *action; uint32_t hand; XrPosef offset; } gn_action_space; + +static XrInstance current_instance; +static XrSession current_session; +static gn_path_entry paths[GN_PATHS]; +static uint32_t path_count; +static gn_action_set sets[GN_ACTION_SETS]; +static gn_action actions[GN_ACTIONS]; +static gn_action_space spaces[GN_ACTION_SPACES]; +static gamenative_control_input inputs[2]; +static uint64_t sync_serial; + +static gn_action_set *valid_set(XrActionSet handle) { + gn_action_set *set = (gn_action_set *)handle; + return set >= sets && set < sets + GN_ACTION_SETS && set->magic == GN_SET_MAGIC ? set : NULL; +} + +static gn_action *valid_action(XrAction handle) { + gn_action *action = (gn_action *)handle; + return action >= actions && action < actions + GN_ACTIONS && action->magic == GN_ACTION_MAGIC ? action : NULL; +} + +static const char *path_value(XrPath path) { + uint64_t index = (uint64_t)path; + return index && index <= path_count ? paths[index - 1].value : NULL; +} + +static int path_hand(XrPath path) { + const char *value = path_value(path); + if (!value) return -1; + if (strstr(value, "/user/hand/left") == value) return 0; + if (strstr(value, "/user/hand/right") == value) return 1; + return -1; +} + +static XrPath action_binding(gn_action *action, XrPath subaction, int *hand) { + int requested = path_hand(subaction); + if (requested >= 0 && action->bindings[requested]) { *hand = requested; return action->bindings[requested]; } + for (int i = 0; i < 2; ++i) if (action->bindings[i]) { *hand = i; return action->bindings[i]; } + *hand = requested >= 0 ? requested : 0; + return XR_NULL_PATH; +} + +void gamenative_actions_set_context(XrInstance instance, XrSession session) { + current_instance = instance; + current_session = session; +} + +void gamenative_actions_reset(void) { + memset(sets, 0, sizeof(sets)); + memset(actions, 0, sizeof(actions)); + memset(spaces, 0, sizeof(spaces)); + memset(inputs, 0, sizeof(inputs)); + current_session = XR_NULL_HANDLE; + current_instance = XR_NULL_HANDLE; +} + +void gamenative_actions_end_session(void) { + memset(spaces, 0, sizeof(spaces)); + memset(inputs, 0, sizeof(inputs)); + for (uint32_t i = 0; i < GN_ACTION_SETS; ++i) sets[i].attached = 0; + current_session = XR_NULL_HANDLE; +} + +XrResult XRAPI_CALL gamenative_string_to_path(XrInstance instance, const char *string, XrPath *path) { + if (instance != current_instance) return XR_ERROR_HANDLE_INVALID; + if (!string || !path || string[0] != '/' || strlen(string) >= XR_MAX_PATH_LENGTH) return XR_ERROR_PATH_FORMAT_INVALID; + for (uint32_t i = 0; i < path_count; ++i) if (!strcmp(paths[i].value, string)) { *path = (XrPath)(i + 1); return XR_SUCCESS; } + if (path_count == GN_PATHS) return XR_ERROR_PATH_COUNT_EXCEEDED; + strcpy_s(paths[path_count].value, sizeof(paths[path_count].value), string); + *path = (XrPath)(++path_count); + return XR_SUCCESS; +} + +XrResult XRAPI_CALL gamenative_path_to_string(XrInstance instance, XrPath path, uint32_t capacity, uint32_t *count, char *buffer) { + if (instance != current_instance) return XR_ERROR_HANDLE_INVALID; + const char *value = path_value(path); + if (!value) return XR_ERROR_PATH_INVALID; + if (!count) return XR_ERROR_VALIDATION_FAILURE; + *count = (uint32_t)strlen(value) + 1; + if (!capacity) return XR_SUCCESS; + if (capacity < *count || !buffer) return XR_ERROR_SIZE_INSUFFICIENT; + memcpy(buffer, value, *count); + return XR_SUCCESS; +} + +XrResult XRAPI_CALL gamenative_create_action_set(XrInstance instance, const XrActionSetCreateInfo *info, XrActionSet *handle) { + if (instance != current_instance) return XR_ERROR_HANDLE_INVALID; + if (!info || info->type != XR_TYPE_ACTION_SET_CREATE_INFO || !handle || !info->actionSetName[0]) return XR_ERROR_VALIDATION_FAILURE; + for (uint32_t i = 0; i < GN_ACTION_SETS; ++i) if (!sets[i].magic) { sets[i].magic = GN_SET_MAGIC; sets[i].owner = instance; *handle = (XrActionSet)&sets[i]; return XR_SUCCESS; } + return XR_ERROR_LIMIT_REACHED; +} + +XrResult XRAPI_CALL gamenative_destroy_action_set(XrActionSet handle) { + gn_action_set *set = valid_set(handle); + if (!set) return XR_ERROR_HANDLE_INVALID; + for (uint32_t i = 0; i < GN_ACTIONS; ++i) if (actions[i].magic && actions[i].set == set) memset(&actions[i], 0, sizeof(actions[i])); + memset(set, 0, sizeof(*set)); + return XR_SUCCESS; +} + +XrResult XRAPI_CALL gamenative_create_action(XrActionSet set_handle, const XrActionCreateInfo *info, XrAction *handle) { + gn_action_set *set = valid_set(set_handle); + if (!set) return XR_ERROR_HANDLE_INVALID; + if (!info || info->type != XR_TYPE_ACTION_CREATE_INFO || !handle || !info->actionName[0] || set->attached) return XR_ERROR_VALIDATION_FAILURE; + if (info->countSubactionPaths > 2 || (info->countSubactionPaths && !info->subactionPaths)) return XR_ERROR_PATH_UNSUPPORTED; + for (uint32_t i = 0; i < info->countSubactionPaths; ++i) if (path_hand(info->subactionPaths[i]) < 0) return XR_ERROR_PATH_UNSUPPORTED; + for (uint32_t i = 0; i < GN_ACTIONS; ++i) if (!actions[i].magic) { actions[i].magic = GN_ACTION_MAGIC; actions[i].set = set; actions[i].type = info->actionType; *handle = (XrAction)&actions[i]; return XR_SUCCESS; } + return XR_ERROR_LIMIT_REACHED; +} + +XrResult XRAPI_CALL gamenative_destroy_action(XrAction handle) { + gn_action *action = valid_action(handle); + if (!action) return XR_ERROR_HANDLE_INVALID; + memset(action, 0, sizeof(*action)); + return XR_SUCCESS; +} + +XrResult XRAPI_CALL gamenative_suggest_bindings(XrInstance instance, const XrInteractionProfileSuggestedBinding *info) { + if (instance != current_instance) return XR_ERROR_HANDLE_INVALID; + if (!info || info->type != XR_TYPE_INTERACTION_PROFILE_SUGGESTED_BINDING || !path_value(info->interactionProfile) || (info->countSuggestedBindings && !info->suggestedBindings)) return XR_ERROR_VALIDATION_FAILURE; + for (uint32_t i = 0; i < info->countSuggestedBindings; ++i) { + gn_action *action = valid_action(info->suggestedBindings[i].action); + int hand = path_hand(info->suggestedBindings[i].binding); + if (!action || hand < 0) return XR_ERROR_PATH_UNSUPPORTED; + action->bindings[hand] = info->suggestedBindings[i].binding; + } + return XR_SUCCESS; +} + +XrResult XRAPI_CALL gamenative_attach_action_sets(XrSession session, const XrSessionActionSetsAttachInfo *info) { + if (session != current_session) return XR_ERROR_HANDLE_INVALID; + if (!info || info->type != XR_TYPE_SESSION_ACTION_SETS_ATTACH_INFO || !info->countActionSets || !info->actionSets) return XR_ERROR_VALIDATION_FAILURE; + for (uint32_t i = 0; i < info->countActionSets; ++i) { gn_action_set *set = valid_set(info->actionSets[i]); if (!set) return XR_ERROR_HANDLE_INVALID; set->attached = 1; } + return XR_SUCCESS; +} + +XrResult XRAPI_CALL gamenative_sync_actions(XrSession session, const XrActionsSyncInfo *info) { + if (session != current_session) return XR_ERROR_HANDLE_INVALID; + if (!info || info->type != XR_TYPE_ACTIONS_SYNC_INFO || !info->countActiveActionSets || !info->activeActionSets) return XR_ERROR_VALIDATION_FAILURE; + for (uint32_t i = 0; i < info->countActiveActionSets; ++i) if (!valid_set(info->activeActionSets[i].actionSet)) return XR_ERROR_HANDLE_INVALID; + if (gamenative_control_get_input(0, &inputs[0]) || gamenative_control_get_input(1, &inputs[1])) return XR_ERROR_RUNTIME_FAILURE; + ++sync_serial; + return XR_SUCCESS; +} + +static XrResult action_info(XrSession session, const XrActionStateGetInfo *info, XrActionType type, gn_action **action, int *hand, const char **binding) { + if (session != current_session) return XR_ERROR_HANDLE_INVALID; + if (!info || info->type != XR_TYPE_ACTION_STATE_GET_INFO) return XR_ERROR_VALIDATION_FAILURE; + *action = valid_action(info->action); + if (!*action) return XR_ERROR_HANDLE_INVALID; + if ((*action)->type != type) return XR_ERROR_ACTION_TYPE_MISMATCH; + XrPath path = action_binding(*action, info->subactionPath, hand); + *binding = path_value(path); + return XR_SUCCESS; +} + +XrResult XRAPI_CALL gamenative_get_action_boolean(XrSession session, const XrActionStateGetInfo *info, XrActionStateBoolean *state) { + if (!state || state->type != XR_TYPE_ACTION_STATE_BOOLEAN) return XR_ERROR_VALIDATION_FAILURE; + gn_action *action; int hand; const char *binding; + XrResult result = action_info(session, info, XR_ACTION_TYPE_BOOLEAN_INPUT, &action, &hand, &binding); + if (XR_FAILED(result)) return result; + uint32_t mask = 0; + if (binding) { + if (strstr(binding, "/input/a/")) mask = 1u << 0; + else if (strstr(binding, "/input/b/")) mask = 1u << 1; + else if (strstr(binding, "/input/x/")) mask = 1u << 2; + else if (strstr(binding, "/input/y/")) mask = 1u << 3; + else if (strstr(binding, "/squeeze/")) mask = 1u << (hand ? 5 : 4); + else if (strstr(binding, "/menu/")) mask = 1u << 6; + else if (strstr(binding, "/thumbstick/")) mask = 1u << (hand ? 9 : 8); + } + state->currentState = mask && (inputs[hand].buttons & mask) ? XR_TRUE : XR_FALSE; + state->changedSinceLastSync = XR_FALSE; + state->lastChangeTime = 0; + state->isActive = binding && inputs[hand].active ? XR_TRUE : XR_FALSE; + return XR_SUCCESS; +} + +XrResult XRAPI_CALL gamenative_get_action_float(XrSession session, const XrActionStateGetInfo *info, XrActionStateFloat *state) { + if (!state || state->type != XR_TYPE_ACTION_STATE_FLOAT) return XR_ERROR_VALIDATION_FAILURE; + gn_action *action; int hand; const char *binding; + XrResult result = action_info(session, info, XR_ACTION_TYPE_FLOAT_INPUT, &action, &hand, &binding); + if (XR_FAILED(result)) return result; + state->currentState = binding && strstr(binding, "/trigger/") ? inputs[hand].trigger / 1000000.0f : inputs[hand].squeeze / 1000000.0f; + state->changedSinceLastSync = XR_FALSE; + state->lastChangeTime = 0; + state->isActive = binding && inputs[hand].active ? XR_TRUE : XR_FALSE; + return XR_SUCCESS; +} + +XrResult XRAPI_CALL gamenative_get_action_vector(XrSession session, const XrActionStateGetInfo *info, XrActionStateVector2f *state) { + if (!state || state->type != XR_TYPE_ACTION_STATE_VECTOR2F) return XR_ERROR_VALIDATION_FAILURE; + gn_action *action; int hand; const char *binding; + XrResult result = action_info(session, info, XR_ACTION_TYPE_VECTOR2F_INPUT, &action, &hand, &binding); + if (XR_FAILED(result)) return result; + state->currentState.x = inputs[hand].stick[0] / 1000000.0f; + state->currentState.y = inputs[hand].stick[1] / 1000000.0f; + state->changedSinceLastSync = XR_FALSE; + state->lastChangeTime = 0; + state->isActive = binding && inputs[hand].active ? XR_TRUE : XR_FALSE; + return XR_SUCCESS; +} + +XrResult XRAPI_CALL gamenative_get_action_pose(XrSession session, const XrActionStateGetInfo *info, XrActionStatePose *state) { + if (!state || state->type != XR_TYPE_ACTION_STATE_POSE) return XR_ERROR_VALIDATION_FAILURE; + gn_action *action; int hand; const char *binding; + XrResult result = action_info(session, info, XR_ACTION_TYPE_POSE_INPUT, &action, &hand, &binding); + if (XR_FAILED(result)) return result; + state->isActive = binding && inputs[hand].active ? XR_TRUE : XR_FALSE; + return XR_SUCCESS; +} + +XrResult XRAPI_CALL gamenative_create_action_space(XrSession session, const XrActionSpaceCreateInfo *info, XrSpace *handle) { + if (session != current_session) return XR_ERROR_HANDLE_INVALID; + if (!info || info->type != XR_TYPE_ACTION_SPACE_CREATE_INFO || !handle) return XR_ERROR_VALIDATION_FAILURE; + gn_action *action = valid_action(info->action); + if (!action || action->type != XR_ACTION_TYPE_POSE_INPUT) return action ? XR_ERROR_ACTION_TYPE_MISMATCH : XR_ERROR_HANDLE_INVALID; + int hand = path_hand(info->subactionPath); + if (hand < 0) { int selected; action_binding(action, XR_NULL_PATH, &selected); hand = selected; } + for (uint32_t i = 0; i < GN_ACTION_SPACES; ++i) if (!spaces[i].magic) { spaces[i].magic = GN_SPACE_MAGIC; spaces[i].owner = session; spaces[i].action = action; spaces[i].hand = hand; spaces[i].offset = info->poseInActionSpace; *handle = (XrSpace)&spaces[i]; return XR_SUCCESS; } + return XR_ERROR_LIMIT_REACHED; +} + +XrResult XRAPI_CALL gamenative_locate_space(XrSpace handle, XrSpace base, XrTime time, XrSpaceLocation *location) { + (void)time; + if (!handle || !base) return XR_ERROR_HANDLE_INVALID; + if (!location || location->type != XR_TYPE_SPACE_LOCATION) return XR_ERROR_VALIDATION_FAILURE; + location->pose.orientation.w = 1.0f; + location->locationFlags = XR_SPACE_LOCATION_ORIENTATION_VALID_BIT | XR_SPACE_LOCATION_POSITION_VALID_BIT; + gn_action_space *space = (gn_action_space *)handle; + if (space >= spaces && space < spaces + GN_ACTION_SPACES && space->magic == GN_SPACE_MAGIC) { + uint32_t hand = space->hand; + int32_t *orientation = inputs[hand].aim_orientation; + int32_t *position = inputs[hand].aim_position; + const char *binding = path_value(space->action->bindings[hand]); + if (binding && strstr(binding, "/grip/")) { + orientation = inputs[hand].grip_orientation; + position = inputs[hand].grip_position; + } + location->pose.orientation.x = orientation[0] / 1000000.0f; + location->pose.orientation.y = orientation[1] / 1000000.0f; + location->pose.orientation.z = orientation[2] / 1000000.0f; + location->pose.orientation.w = orientation[3] / 1000000.0f; + location->pose.position.x = position[0] / 1000000.0f + space->offset.position.x; + location->pose.position.y = position[1] / 1000000.0f + space->offset.position.y; + location->pose.position.z = position[2] / 1000000.0f + space->offset.position.z; + if (!inputs[hand].active) location->locationFlags = 0; + } + return XR_SUCCESS; +} + +XrResult gamenative_destroy_action_space(XrSpace handle) { + gn_action_space *space = (gn_action_space *)handle; + if (space < spaces || space >= spaces + GN_ACTION_SPACES || space->magic != GN_SPACE_MAGIC) return XR_ERROR_HANDLE_INVALID; + memset(space, 0, sizeof(*space)); + return XR_SUCCESS; +} + +XrResult XRAPI_CALL gamenative_enumerate_bound_sources(XrSession session, const XrBoundSourcesForActionEnumerateInfo *info, uint32_t capacity, uint32_t *count, XrPath *sources) { + if (session != current_session) return XR_ERROR_HANDLE_INVALID; + if (!info || info->type != XR_TYPE_BOUND_SOURCES_FOR_ACTION_ENUMERATE_INFO || !count) return XR_ERROR_VALIDATION_FAILURE; + gn_action *action = valid_action(info->action); + if (!action) return XR_ERROR_HANDLE_INVALID; + uint32_t total = (action->bindings[0] ? 1u : 0u) + (action->bindings[1] ? 1u : 0u); + *count = total; + if (!capacity) return XR_SUCCESS; + if (capacity < total || !sources) return XR_ERROR_SIZE_INSUFFICIENT; + uint32_t output = 0; + for (uint32_t hand = 0; hand < 2; ++hand) if (action->bindings[hand]) sources[output++] = action->bindings[hand]; + return XR_SUCCESS; +} + +XrResult XRAPI_CALL gamenative_get_source_name(XrSession session, const XrInputSourceLocalizedNameGetInfo *info, uint32_t capacity, uint32_t *count, char *buffer) { + if (session != current_session) return XR_ERROR_HANDLE_INVALID; + if (!info || info->type != XR_TYPE_INPUT_SOURCE_LOCALIZED_NAME_GET_INFO || !count) return XR_ERROR_VALIDATION_FAILURE; + const char *path = path_value(info->sourcePath); + if (!path) return XR_ERROR_PATH_INVALID; + char name[256] = ""; + if (info->whichComponents & XR_INPUT_SOURCE_LOCALIZED_NAME_USER_PATH_BIT) strcat_s(name, sizeof(name), strstr(path, "/left/") ? "Left Hand" : "Right Hand"); + if (info->whichComponents & XR_INPUT_SOURCE_LOCALIZED_NAME_INTERACTION_PROFILE_BIT) strcat_s(name, sizeof(name), name[0] ? " Quest Touch" : "Quest Touch"); + if (info->whichComponents & XR_INPUT_SOURCE_LOCALIZED_NAME_COMPONENT_BIT) { const char *component = strstr(path, "/input/"); if (!component) component = strstr(path, "/output/"); if (component) strcat_s(name, sizeof(name), component); } + *count = (uint32_t)strlen(name) + 1; + if (!capacity) return XR_SUCCESS; + if (capacity < *count || !buffer) return XR_ERROR_SIZE_INSUFFICIENT; + memcpy(buffer, name, *count); + return XR_SUCCESS; +} + +XrResult XRAPI_CALL gamenative_get_interaction_profile(XrSession session, XrPath top_level, XrInteractionProfileState *state) { + if (session != current_session) return XR_ERROR_HANDLE_INVALID; + if (!state || state->type != XR_TYPE_INTERACTION_PROFILE_STATE || path_hand(top_level) < 0) return XR_ERROR_VALIDATION_FAILURE; + return gamenative_string_to_path(current_instance, "/interaction_profiles/oculus/touch_controller", &state->interactionProfile); +} + +XrResult XRAPI_CALL gamenative_apply_haptic(XrSession session, const XrHapticActionInfo *info, const XrHapticBaseHeader *feedback) { + if (session != current_session) return XR_ERROR_HANDLE_INVALID; + if (!info || info->type != XR_TYPE_HAPTIC_ACTION_INFO || !feedback || feedback->type != XR_TYPE_HAPTIC_VIBRATION) return XR_ERROR_VALIDATION_FAILURE; + gn_action *action = valid_action(info->action); + if (!action || action->type != XR_ACTION_TYPE_VIBRATION_OUTPUT) return action ? XR_ERROR_ACTION_TYPE_MISMATCH : XR_ERROR_HANDLE_INVALID; + int hand; action_binding(action, info->subactionPath, &hand); + const XrHapticVibration *vibration = (const XrHapticVibration *)feedback; + int32_t amplitude = (int32_t)(vibration->amplitude * 1000000.0f); + int32_t frequency = vibration->frequency == XR_FREQUENCY_UNSPECIFIED ? 0 : (int32_t)(vibration->frequency * 1000000.0f); + return gamenative_control_haptic(hand, amplitude, vibration->duration, frequency) == 0 ? XR_SUCCESS : XR_ERROR_RUNTIME_FAILURE; +} + +XrResult XRAPI_CALL gamenative_stop_haptic(XrSession session, const XrHapticActionInfo *info) { + if (!info || info->type != XR_TYPE_HAPTIC_ACTION_INFO) return XR_ERROR_VALIDATION_FAILURE; + gn_action *action = valid_action(info->action); + if (!action) return XR_ERROR_HANDLE_INVALID; + int hand; action_binding(action, info->subactionPath, &hand); + return session == current_session && gamenative_control_haptic(hand, 0, 0, 0) == 0 ? XR_SUCCESS : XR_ERROR_RUNTIME_FAILURE; +} diff --git a/app/src/main/windows/openxr_runtime/gamenative_actions.h b/app/src/main/windows/openxr_runtime/gamenative_actions.h new file mode 100644 index 0000000000..3b7b16959d --- /dev/null +++ b/app/src/main/windows/openxr_runtime/gamenative_actions.h @@ -0,0 +1,31 @@ +#ifndef GAMENATIVE_ACTIONS_H +#define GAMENATIVE_ACTIONS_H + +#include + +void gamenative_actions_set_context(XrInstance instance, XrSession session); +void gamenative_actions_reset(void); +void gamenative_actions_end_session(void); +XrResult XRAPI_CALL gamenative_string_to_path(XrInstance instance, const char *string, XrPath *path); +XrResult XRAPI_CALL gamenative_path_to_string(XrInstance instance, XrPath path, uint32_t capacity, uint32_t *count, char *buffer); +XrResult XRAPI_CALL gamenative_create_action_set(XrInstance instance, const XrActionSetCreateInfo *info, XrActionSet *set); +XrResult XRAPI_CALL gamenative_destroy_action_set(XrActionSet set); +XrResult XRAPI_CALL gamenative_create_action(XrActionSet set, const XrActionCreateInfo *info, XrAction *action); +XrResult XRAPI_CALL gamenative_destroy_action(XrAction action); +XrResult XRAPI_CALL gamenative_suggest_bindings(XrInstance instance, const XrInteractionProfileSuggestedBinding *bindings); +XrResult XRAPI_CALL gamenative_attach_action_sets(XrSession session, const XrSessionActionSetsAttachInfo *info); +XrResult XRAPI_CALL gamenative_sync_actions(XrSession session, const XrActionsSyncInfo *info); +XrResult XRAPI_CALL gamenative_get_action_boolean(XrSession session, const XrActionStateGetInfo *info, XrActionStateBoolean *state); +XrResult XRAPI_CALL gamenative_get_action_float(XrSession session, const XrActionStateGetInfo *info, XrActionStateFloat *state); +XrResult XRAPI_CALL gamenative_get_action_vector(XrSession session, const XrActionStateGetInfo *info, XrActionStateVector2f *state); +XrResult XRAPI_CALL gamenative_get_action_pose(XrSession session, const XrActionStateGetInfo *info, XrActionStatePose *state); +XrResult XRAPI_CALL gamenative_create_action_space(XrSession session, const XrActionSpaceCreateInfo *info, XrSpace *space); +XrResult XRAPI_CALL gamenative_locate_space(XrSpace space, XrSpace base, XrTime time, XrSpaceLocation *location); +XrResult gamenative_destroy_action_space(XrSpace space); +XrResult XRAPI_CALL gamenative_enumerate_bound_sources(XrSession session, const XrBoundSourcesForActionEnumerateInfo *info, uint32_t capacity, uint32_t *count, XrPath *sources); +XrResult XRAPI_CALL gamenative_get_source_name(XrSession session, const XrInputSourceLocalizedNameGetInfo *info, uint32_t capacity, uint32_t *count, char *buffer); +XrResult XRAPI_CALL gamenative_get_interaction_profile(XrSession session, XrPath top_level, XrInteractionProfileState *state); +XrResult XRAPI_CALL gamenative_apply_haptic(XrSession session, const XrHapticActionInfo *info, const XrHapticBaseHeader *feedback); +XrResult XRAPI_CALL gamenative_stop_haptic(XrSession session, const XrHapticActionInfo *info); + +#endif diff --git a/app/src/main/windows/openxr_runtime/gamenative_control.c b/app/src/main/windows/openxr_runtime/gamenative_control.c new file mode 100644 index 0000000000..bb5212ed29 --- /dev/null +++ b/app/src/main/windows/openxr_runtime/gamenative_control.c @@ -0,0 +1,198 @@ +#include "gamenative_control.h" + +#include +#include +#include +#include +#include + +static SOCKET control_socket = INVALID_SOCKET; +static CRITICAL_SECTION control_lock; +static INIT_ONCE control_once = INIT_ONCE_STATIC_INIT; + +static BOOL CALLBACK initialize_control(PINIT_ONCE once, PVOID parameter, PVOID *context) { + WSADATA data; + (void)once; + (void)parameter; + (void)context; + InitializeCriticalSection(&control_lock); + return WSAStartup(MAKEWORD(2, 2), &data) == 0; +} + +static int send_all(const char *data, int length) { + while (length > 0) { + int sent = send(control_socket, data, length, 0); + if (sent <= 0) return -1; + data += sent; + length -= sent; + } + return 0; +} + +static int receive_line(char *response, uint32_t capacity) { + uint32_t length = 0; + while (length + 1 < capacity) { + char value; + if (recv(control_socket, &value, 1, 0) != 1) return -1; + if (value == '\n') { + response[length] = '\0'; + return 0; + } + if (value == '\r' || value == '\0') return -1; + response[length++] = value; + } + return -1; +} + +int gamenative_control_connect(void) { + InitOnceExecuteOnce(&control_once, initialize_control, NULL, NULL); + EnterCriticalSection(&control_lock); + if (control_socket != INVALID_SOCKET) { + LeaveCriticalSection(&control_lock); + return 0; + } + control_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + if (control_socket == INVALID_SOCKET) { + LeaveCriticalSection(&control_lock); + return -1; + } + BOOL no_delay = TRUE; + setsockopt(control_socket, IPPROTO_TCP, TCP_NODELAY, (const char *)&no_delay, sizeof(no_delay)); + DWORD timeout = 15000; + setsockopt(control_socket, SOL_SOCKET, SO_RCVTIMEO, (const char *)&timeout, sizeof(timeout)); + struct sockaddr_in address; + memset(&address, 0, sizeof(address)); + address.sin_family = AF_INET; + address.sin_port = htons(38476); + InetPtonA(AF_INET, "127.0.0.1", &address.sin_addr); + if (connect(control_socket, (const struct sockaddr *)&address, sizeof(address)) != 0) { + closesocket(control_socket); + control_socket = INVALID_SOCKET; + LeaveCriticalSection(&control_lock); + return -1; + } + const char hello[] = "HELLO\n"; + char response[128]; + int result = send_all(hello, (int)strlen(hello)) == 0 && receive_line(response, sizeof(response)) == 0 && + strcmp(response, "OK GameNativeVR 2") == 0 ? 0 : -1; + if (result != 0) { + closesocket(control_socket); + control_socket = INVALID_SOCKET; + } + LeaveCriticalSection(&control_lock); + return result; +} + +void gamenative_control_disconnect(void) { + InitOnceExecuteOnce(&control_once, initialize_control, NULL, NULL); + EnterCriticalSection(&control_lock); + if (control_socket != INVALID_SOCKET) { + send_all("BYE\n", 4); + shutdown(control_socket, SD_BOTH); + closesocket(control_socket); + control_socket = INVALID_SOCKET; + } + LeaveCriticalSection(&control_lock); +} + +int gamenative_control_request(const char *command, char *response, uint32_t capacity) { + if (command == NULL || response == NULL || capacity < 2 || strlen(command) > 1023) return -1; + if (gamenative_control_connect() != 0) return -1; + EnterCriticalSection(&control_lock); + int result = send_all(command, (int)strlen(command)); + if (result == 0 && command[strlen(command) - 1] != '\n') result = send_all("\n", 1); + if (result == 0) result = receive_line(response, capacity); + if (result != 0) { + closesocket(control_socket); + control_socket = INVALID_SOCKET; + } + LeaveCriticalSection(&control_lock); + return result; +} + +int gamenative_control_wait_frame(gamenative_control_frame *frame) { + char response[512]; + if (frame == NULL || gamenative_control_request("WAIT_FRAME", response, sizeof(response)) != 0) return -1; + unsigned long long serial = 0; + long long time = 0; + long long period = 0; + unsigned int render = 0; + unsigned int state = 0; + if (sscanf_s(response, "OK serial=%llu time=%lld period=%lld shouldRender=%u state=%u", + &serial, &time, &period, &render, &state) != 5) return -1; + frame->serial = serial; + frame->display_time = time; + frame->display_period = period; + frame->should_render = render; + frame->session_state = state; + return 0; +} + +int gamenative_control_get_views(uint32_t *width, uint32_t *height) { + char response[256]; + unsigned int count = 0; + if (width == NULL || height == NULL || + gamenative_control_request("GET_VIEWS", response, sizeof(response)) != 0) return -1; + if (sscanf_s(response, "OK count=%u width=%u height=%u", &count, width, height) != 3 || + count != 2 || *width == 0 || *height == 0 || *width > 8192 || *height > 8192) return -1; + return 0; +} + +int gamenative_control_get_bounds(uint32_t *available, uint32_t *width, uint32_t *height) { + char response[256]; + if (available == NULL || width == NULL || height == NULL || + gamenative_control_request("GET_BOUNDS", response, sizeof(response)) != 0) return -1; + if (sscanf_s(response, "OK available=%u width=%u height=%u", available, width, height) != 3 || + *available > 1 || *width > 100000000 || *height > 100000000) return -1; + return 0; +} + +int gamenative_control_locate_views(gamenative_control_view views[2], uint32_t *flags) { + char response[1024]; + if (views == NULL || flags == NULL || gamenative_control_request("LOCATE_VIEWS", response, sizeof(response)) != 0) return -1; + int consumed = 0; + if (sscanf_s(response, "OK flags=%u %n", flags, &consumed) < 1 || consumed <= 0) return -1; + const char *cursor = response + consumed; + for (uint32_t eye = 0; eye < 2; ++eye) { + int *values[] = { + &views[eye].orientation[0], &views[eye].orientation[1], &views[eye].orientation[2], &views[eye].orientation[3], + &views[eye].position[0], &views[eye].position[1], &views[eye].position[2], + &views[eye].fov[0], &views[eye].fov[1], &views[eye].fov[2], &views[eye].fov[3], + }; + for (uint32_t value = 0; value < 11; ++value) { + char *end = NULL; + long parsed = strtol(cursor, &end, 10); + if (end == cursor) return -1; + *values[value] = (int32_t)parsed; + cursor = end; + while (*cursor == ' ') ++cursor; + } + } + return 0; +} + +int gamenative_control_get_input(uint32_t hand, gamenative_control_input *input) { + if (hand > 1 || input == NULL) return -1; + char command[32]; + char response[512]; + sprintf_s(command, sizeof(command), "GET_INPUT hand=%u", hand); + if (gamenative_control_request(command, response, sizeof(response)) != 0) return -1; + return sscanf_s(response, + "OK active=%u buttons=%u %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d", + &input->active, &input->buttons, &input->trigger, &input->squeeze, + &input->stick[0], &input->stick[1], + &input->grip_orientation[0], &input->grip_orientation[1], + &input->grip_orientation[2], &input->grip_orientation[3], + &input->grip_position[0], &input->grip_position[1], &input->grip_position[2], + &input->aim_orientation[0], &input->aim_orientation[1], + &input->aim_orientation[2], &input->aim_orientation[3], + &input->aim_position[0], &input->aim_position[1], &input->aim_position[2]) == 20 ? 0 : -1; +} + +int gamenative_control_haptic(uint32_t hand, int32_t amplitude, int64_t duration, int32_t frequency) { + if (hand > 1 || amplitude < 0 || amplitude > 1000000 || duration < 0 || frequency < 0) return -1; + char command[160]; + char response[128]; + sprintf_s(command, sizeof(command), "HAPTIC hand=%u amp=%d dur=%lld freq=%d", hand, amplitude, duration, frequency); + return gamenative_control_request(command, response, sizeof(response)) == 0 && strcmp(response, "OK") == 0 ? 0 : -1; +} diff --git a/app/src/main/windows/openxr_runtime/gamenative_control.h b/app/src/main/windows/openxr_runtime/gamenative_control.h new file mode 100644 index 0000000000..24ece0eecf --- /dev/null +++ b/app/src/main/windows/openxr_runtime/gamenative_control.h @@ -0,0 +1,42 @@ +#ifndef GAMENATIVE_CONTROL_H +#define GAMENATIVE_CONTROL_H + +#include + +typedef struct gamenative_control_frame { + uint64_t serial; + int64_t display_time; + int64_t display_period; + uint32_t should_render; + uint32_t session_state; +} gamenative_control_frame; + +typedef struct gamenative_control_view { + int32_t orientation[4]; + int32_t position[3]; + int32_t fov[4]; +} gamenative_control_view; + +typedef struct gamenative_control_input { + uint32_t active; + uint32_t buttons; + int32_t trigger; + int32_t squeeze; + int32_t stick[2]; + int32_t grip_orientation[4]; + int32_t grip_position[3]; + int32_t aim_orientation[4]; + int32_t aim_position[3]; +} gamenative_control_input; + +int gamenative_control_connect(void); +void gamenative_control_disconnect(void); +int gamenative_control_request(const char *command, char *response, uint32_t capacity); +int gamenative_control_wait_frame(gamenative_control_frame *frame); +int gamenative_control_get_views(uint32_t *width, uint32_t *height); +int gamenative_control_get_bounds(uint32_t *available, uint32_t *width, uint32_t *height); +int gamenative_control_locate_views(gamenative_control_view views[2], uint32_t *flags); +int gamenative_control_get_input(uint32_t hand, gamenative_control_input *input); +int gamenative_control_haptic(uint32_t hand, int32_t amplitude, int64_t duration, int32_t frequency); + +#endif diff --git a/app/src/main/windows/openxr_runtime/gamenative_dxvk.c b/app/src/main/windows/openxr_runtime/gamenative_dxvk.c new file mode 100644 index 0000000000..88fe6875c0 --- /dev/null +++ b/app/src/main/windows/openxr_runtime/gamenative_dxvk.c @@ -0,0 +1,108 @@ +#define COBJMACROS +#include "gamenative_dxvk.h" + +#include +#include + +typedef struct IDXGIVkInteropDevice IDXGIVkInteropDevice; +typedef struct IDXGIVkInteropSurface IDXGIVkInteropSurface; + +typedef struct IDXGIVkInteropDeviceVtbl { + HRESULT (STDMETHODCALLTYPE *QueryInterface)(IDXGIVkInteropDevice *, REFIID, void **); + ULONG (STDMETHODCALLTYPE *AddRef)(IDXGIVkInteropDevice *); + ULONG (STDMETHODCALLTYPE *Release)(IDXGIVkInteropDevice *); + void (STDMETHODCALLTYPE *GetVulkanHandles)(IDXGIVkInteropDevice *, uint64_t *, uint64_t *, uint64_t *); + void (STDMETHODCALLTYPE *GetSubmissionQueue)(IDXGIVkInteropDevice *, uint64_t *, uint32_t *); + void (STDMETHODCALLTYPE *TransitionSurfaceLayout)(IDXGIVkInteropDevice *, void *, const void *, uint32_t, uint32_t); + void (STDMETHODCALLTYPE *FlushRenderingCommands)(IDXGIVkInteropDevice *); + void (STDMETHODCALLTYPE *LockSubmissionQueue)(IDXGIVkInteropDevice *); + void (STDMETHODCALLTYPE *ReleaseSubmissionQueue)(IDXGIVkInteropDevice *); +} IDXGIVkInteropDeviceVtbl; + +struct IDXGIVkInteropDevice { const IDXGIVkInteropDeviceVtbl *lpVtbl; }; +typedef struct IDXGIVkInteropSurfaceVtbl { + HRESULT (STDMETHODCALLTYPE *QueryInterface)(IDXGIVkInteropSurface *, REFIID, void **); + ULONG (STDMETHODCALLTYPE *AddRef)(IDXGIVkInteropSurface *); + ULONG (STDMETHODCALLTYPE *Release)(IDXGIVkInteropSurface *); + HRESULT (STDMETHODCALLTYPE *GetDevice)(IDXGIVkInteropSurface *, IDXGIVkInteropDevice **); + HRESULT (STDMETHODCALLTYPE *GetVulkanImageInfo)(IDXGIVkInteropSurface *, uint64_t *, uint32_t *, void *); +} IDXGIVkInteropSurfaceVtbl; +struct IDXGIVkInteropSurface { const IDXGIVkInteropSurfaceVtbl *lpVtbl; }; +typedef struct IDXGIVkInteropDevice1Vtbl { + HRESULT (STDMETHODCALLTYPE *QueryInterface)(IDXGIVkInteropDevice *, REFIID, void **); + ULONG (STDMETHODCALLTYPE *AddRef)(IDXGIVkInteropDevice *); + ULONG (STDMETHODCALLTYPE *Release)(IDXGIVkInteropDevice *); + void (STDMETHODCALLTYPE *GetVulkanHandles)(IDXGIVkInteropDevice *, uint64_t *, uint64_t *, uint64_t *); + void (STDMETHODCALLTYPE *GetSubmissionQueue)(IDXGIVkInteropDevice *, uint64_t *, uint32_t *); + void (STDMETHODCALLTYPE *TransitionSurfaceLayout)(IDXGIVkInteropDevice *, void *, const void *, uint32_t, uint32_t); + void (STDMETHODCALLTYPE *FlushRenderingCommands)(IDXGIVkInteropDevice *); + void (STDMETHODCALLTYPE *LockSubmissionQueue)(IDXGIVkInteropDevice *); + void (STDMETHODCALLTYPE *ReleaseSubmissionQueue)(IDXGIVkInteropDevice *); + void (STDMETHODCALLTYPE *GetSubmissionQueue1)(IDXGIVkInteropDevice *, uint64_t *, uint32_t *, uint32_t *); + HRESULT (STDMETHODCALLTYPE *CreateTexture2DFromVkImage)(IDXGIVkInteropDevice *, const void *, ID3D11Texture2D **); +} IDXGIVkInteropDevice1Vtbl; + +struct gamenative_dxvk_context { IDXGIVkInteropDevice *interop; uint32_t device1; }; + +static const GUID iid_dxgi_vk_interop_device = {0xe2ef5fa5, 0xdc21, 0x4af7, {0x90, 0xc4, 0xf6, 0x7e, 0xf6, 0xa0, 0x93, 0x23}}; +static const GUID iid_dxgi_vk_interop_device1 = {0xe2ef5fa5, 0xdc21, 0x4af7, {0x90, 0xc4, 0xf6, 0x7e, 0xf6, 0xa0, 0x93, 0x24}}; +static const GUID iid_dxgi_vk_interop_surface = {0x5546cf8c, 0x77e7, 0x4341, {0xb0, 0x5d, 0x8d, 0x4d, 0x50, 0x00, 0xe7, 0x7d}}; + +HRESULT gamenative_dxvk_open(ID3D11Device *device, gamenative_dxvk_context **output, gamenative_xr_vulkan_context *vulkan) { + if (!device || !output || !vulkan) return E_INVALIDARG; + *output = NULL; + IDXGIVkInteropDevice *interop = NULL; + HRESULT result = ID3D11Device_QueryInterface(device, &iid_dxgi_vk_interop_device1, (void **)&interop); + uint32_t device1 = SUCCEEDED(result) && interop != NULL; + if (!device1) result = ID3D11Device_QueryInterface(device, &iid_dxgi_vk_interop_device, (void **)&interop); + if (FAILED(result) || !interop) return E_NOINTERFACE; + gamenative_dxvk_context *context = calloc(1, sizeof(*context)); + if (!context) { interop->lpVtbl->Release(interop); return E_OUTOFMEMORY; } + uint64_t instance = 0; + memset(vulkan, 0, sizeof(*vulkan)); + interop->lpVtbl->GetVulkanHandles(interop, &instance, &vulkan->physical_device, &vulkan->device); + if (device1) { + const IDXGIVkInteropDevice1Vtbl *vtable = (const IDXGIVkInteropDevice1Vtbl *)interop->lpVtbl; + vtable->GetSubmissionQueue1(interop, &vulkan->queue, &vulkan->queue_index, &vulkan->queue_family); + } else { + interop->lpVtbl->GetSubmissionQueue(interop, &vulkan->queue, &vulkan->queue_family); + vulkan->queue_index = 0; + } + if (!vulkan->physical_device || !vulkan->device || !vulkan->queue) { interop->lpVtbl->Release(interop); free(context); return E_FAIL; } + vulkan->header.abi_version = GAMENATIVE_XR_UNIX_ABI_VERSION; + vulkan->header.operation = GAMENATIVE_XR_UNIX_SET_VULKAN_CONTEXT; + vulkan->header.payload_size = sizeof(*vulkan); + vulkan->host_handles = 0; + context->interop = interop; + context->device1 = device1; + *output = context; + return S_OK; +} + +void gamenative_dxvk_close(gamenative_dxvk_context *context) { + if (!context) return; + context->interop->lpVtbl->Release(context->interop); + free(context); +} + +void gamenative_dxvk_flush(gamenative_dxvk_context *context) { + if (context) context->interop->lpVtbl->FlushRenderingCommands(context->interop); +} + +void gamenative_dxvk_lock(gamenative_dxvk_context *context) { + if (context) context->interop->lpVtbl->LockSubmissionQueue(context->interop); +} + +void gamenative_dxvk_unlock(gamenative_dxvk_context *context) { + if (context) context->interop->lpVtbl->ReleaseSubmissionQueue(context->interop); +} + +HRESULT gamenative_dxvk_get_image(ID3D11Texture2D *texture, uint64_t *image, uint32_t *layout) { + if (!texture || !image || !layout) return E_INVALIDARG; + IDXGIVkInteropSurface *surface = NULL; + HRESULT result = ID3D11Texture2D_QueryInterface(texture, &iid_dxgi_vk_interop_surface, (void **)&surface); + if (FAILED(result) || !surface) return E_NOINTERFACE; + result = surface->lpVtbl->GetVulkanImageInfo(surface, image, layout, NULL); + surface->lpVtbl->Release(surface); + return result; +} diff --git a/app/src/main/windows/openxr_runtime/gamenative_dxvk.h b/app/src/main/windows/openxr_runtime/gamenative_dxvk.h new file mode 100644 index 0000000000..f04e8972a9 --- /dev/null +++ b/app/src/main/windows/openxr_runtime/gamenative_dxvk.h @@ -0,0 +1,17 @@ +#ifndef GAMENATIVE_DXVK_H +#define GAMENATIVE_DXVK_H + +#include +#include +#include "gamenative_openxr_unix_abi.h" + +typedef struct gamenative_dxvk_context gamenative_dxvk_context; + +HRESULT gamenative_dxvk_open(ID3D11Device *device, gamenative_dxvk_context **context, gamenative_xr_vulkan_context *vulkan); +void gamenative_dxvk_close(gamenative_dxvk_context *context); +void gamenative_dxvk_flush(gamenative_dxvk_context *context); +void gamenative_dxvk_lock(gamenative_dxvk_context *context); +void gamenative_dxvk_unlock(gamenative_dxvk_context *context); +HRESULT gamenative_dxvk_get_image(ID3D11Texture2D *texture, uint64_t *image, uint32_t *layout); + +#endif diff --git a/app/src/main/windows/openxr_runtime/gamenative_openxr_runtime.c b/app/src/main/windows/openxr_runtime/gamenative_openxr_runtime.c new file mode 100644 index 0000000000..34f4147ba5 --- /dev/null +++ b/app/src/main/windows/openxr_runtime/gamenative_openxr_runtime.c @@ -0,0 +1,3360 @@ + + + + +#define XR_NO_PROTOTYPES +#define XR_EXTENSION_PROTOTYPES + +typedef void* VkInstance; +typedef void* VkPhysicalDevice; +typedef void* VkDevice; +typedef void* VkImage; +typedef void* VkQueue; +typedef int VkResult; +typedef struct ID3D11Device ID3D11Device; +typedef struct ID3D11Texture2D ID3D11Texture2D; +typedef struct ID3D12Device ID3D12Device; +typedef struct ID3D12CommandQueue ID3D12CommandQueue; +typedef struct ID3D12Resource ID3D12Resource; +typedef struct LUID { + unsigned long LowPart; + long HighPart; +} LUID; +typedef enum D3D_FEATURE_LEVEL { + D3D_FEATURE_LEVEL_11_0 = 0xb000 +} D3D_FEATURE_LEVEL; + +#include +#include +#include "gamenative_openxr_unix.h" + +#define XR_KHR_D3D11_enable_SPEC_VERSION 11 +#define XR_KHR_D3D11_ENABLE_EXTENSION_NAME "XR_KHR_D3D11_enable" +#define XR_KHR_vulkan_enable_SPEC_VERSION 10 +#define XR_KHR_VULKAN_ENABLE_EXTENSION_NAME "XR_KHR_vulkan_enable" +#define XR_KHR_vulkan_enable2_SPEC_VERSION 4 +#define XR_KHR_VULKAN_ENABLE2_EXTENSION_NAME "XR_KHR_vulkan_enable2" +#define XR_KHR_D3D12_enable_SPEC_VERSION 9 +#define XR_KHR_D3D12_ENABLE_EXTENSION_NAME "XR_KHR_D3D12_enable" + +typedef struct XrGraphicsRequirementsD3D11KHR { + XrStructureType type; + void* XR_MAY_ALIAS next; + LUID adapterLuid; + D3D_FEATURE_LEVEL minFeatureLevel; +} XrGraphicsRequirementsD3D11KHR; + +typedef struct XrGraphicsRequirementsVulkanKHR { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrVersion minApiVersionSupported; + XrVersion maxApiVersionSupported; +} XrGraphicsRequirementsVulkanKHR; + +typedef struct XrVulkanGraphicsDeviceGetInfoKHR { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSystemId systemId; + VkInstance vulkanInstance; +} XrVulkanGraphicsDeviceGetInfoKHR; + +typedef struct XrGraphicsBindingVulkanKHR { + XrStructureType type; + const void* XR_MAY_ALIAS next; + VkInstance instance; + VkPhysicalDevice physicalDevice; + VkDevice device; + unsigned int queueFamilyIndex; + unsigned int queueIndex; +} XrGraphicsBindingVulkanKHR; + +typedef struct XrSwapchainImageVulkanKHR { + XrStructureType type; + void* XR_MAY_ALIAS next; + VkImage image; +} XrSwapchainImageVulkanKHR; + +typedef struct XrGraphicsBindingD3D11KHR { + XrStructureType type; + const void* XR_MAY_ALIAS next; + ID3D11Device* device; +} XrGraphicsBindingD3D11KHR; + +typedef struct XrGraphicsBindingD3D12KHR { + XrStructureType type; + const void* XR_MAY_ALIAS next; + ID3D12Device* device; + ID3D12CommandQueue* queue; +} XrGraphicsBindingD3D12KHR; + +typedef struct XrGraphicsRequirementsD3D12KHR { + XrStructureType type; + void* XR_MAY_ALIAS next; + LUID adapterLuid; + D3D_FEATURE_LEVEL minFeatureLevel; +} XrGraphicsRequirementsD3D12KHR; + +typedef struct XrSwapchainImageD3D11KHR { + XrStructureType type; + void* XR_MAY_ALIAS next; + ID3D11Texture2D* texture; +} XrSwapchainImageD3D11KHR; + +typedef struct XrSwapchainImageD3D12KHR { + XrStructureType type; + void* XR_MAY_ALIAS next; + ID3D12Resource* texture; +} XrSwapchainImageD3D12KHR; + +typedef struct GnGuid { + unsigned long Data1; + unsigned short Data2; + unsigned short Data3; + unsigned char Data4[8]; +} GnGuid; + +typedef struct GnDxgiSampleDesc { + unsigned int Count; + unsigned int Quality; +} GnDxgiSampleDesc; + +typedef struct GnD3D11Texture2DDesc1 { + unsigned int Width; + unsigned int Height; + unsigned int MipLevels; + unsigned int ArraySize; + int Format; + GnDxgiSampleDesc SampleDesc; + int Usage; + unsigned int BindFlags; + unsigned int CPUAccessFlags; + unsigned int MiscFlags; + int TextureLayout; +} GnD3D11Texture2DDesc1; + +typedef struct GnD3D12ResourceDesc1 { + int Dimension; + unsigned long long Alignment; + unsigned long long Width; + unsigned int Height; + unsigned short DepthOrArraySize; + unsigned short MipLevels; + int Format; + GnDxgiSampleDesc SampleDesc; + int Layout; + unsigned int Flags; + unsigned int SamplerFeedbackMipRegion[3]; +} GnD3D12ResourceDesc1; + +typedef void* (__attribute__((stdcall)) *PFN_vkGetInstanceProcAddr)(VkInstance, const char*); +typedef struct XrVulkanInstanceCreateInfoKHR { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSystemId systemId; + XrFlags64 createFlags; + PFN_vkGetInstanceProcAddr pfnGetInstanceProcAddr; + const void* vulkanCreateInfo; + const void* vulkanAllocator; +} XrVulkanInstanceCreateInfoKHR; + +typedef struct XrVulkanDeviceCreateInfoKHR { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSystemId systemId; + XrFlags64 createFlags; + PFN_vkGetInstanceProcAddr pfnGetInstanceProcAddr; + VkPhysicalDevice vulkanPhysicalDevice; + const void* vulkanCreateInfo; + const void* vulkanAllocator; +} XrVulkanDeviceCreateInfoKHR; + +#ifndef NULL +#define NULL ((void*)0) +#endif + +#define GN_EXPORT __declspec(dllexport) +#define GN_IMPORT __declspec(dllimport) +#define GN_STDCALL __attribute__((stdcall)) + +typedef unsigned int gn_uint32; +typedef unsigned long long gn_uint64; +typedef unsigned short gn_uint16; +typedef unsigned long gn_ulong; +#ifdef _WIN64 +typedef unsigned long long gn_size; +typedef unsigned long long gn_socket; +#else +typedef unsigned int gn_size; +typedef unsigned int gn_socket; +#endif + +#define GN_AF_INET 2 +#define GN_SOCK_STREAM 1 +#define GN_IPPROTO_TCP 6 +#define GN_INVALID_SOCKET ((gn_socket)~0ULL) +#define GN_SOCKET_ERROR (-1) + + +void* memcpy(void* destination, const void* source, gn_size size) { + unsigned char* dst = (unsigned char*)destination; + const unsigned char* src = (const unsigned char*)source; + for (gn_size i = 0; i < size; ++i) dst[i] = src[i]; + return destination; +} + +void* memset(void* destination, int value, gn_size size) { + unsigned char* dst = (unsigned char*)destination; + for (gn_size i = 0; i < size; ++i) dst[i] = (unsigned char)value; + return destination; +} + +static void gn_zero_memory(void* destination, gn_size size) { + unsigned char* dst = (unsigned char*)destination; + for (gn_size i = 0; i < size; ++i) dst[i] = 0; +} + +struct gn_in_addr { + gn_ulong s_addr; +}; + +struct gn_sockaddr_in { + short sin_family; + gn_uint16 sin_port; + struct gn_in_addr sin_addr; + char sin_zero[8]; +}; + +struct gn_wsadata { + unsigned char bytes[512]; +}; + +GN_IMPORT int GN_STDCALL WSAStartup(gn_uint16 version, struct gn_wsadata* data); +GN_IMPORT gn_socket GN_STDCALL socket(int af, int type, int protocol); +GN_IMPORT int GN_STDCALL connect(gn_socket s, const void* name, int namelen); +GN_IMPORT int GN_STDCALL send(gn_socket s, const char* buf, int len, int flags); +GN_IMPORT int GN_STDCALL recv(gn_socket s, char* buf, int len, int flags); +GN_IMPORT int GN_STDCALL closesocket(gn_socket s); +GN_IMPORT gn_uint16 GN_STDCALL htons(gn_uint16 hostshort); +GN_IMPORT gn_ulong GN_STDCALL inet_addr(const char* cp); + +GN_IMPORT void* GN_STDCALL CreateFileA(const char* name, gn_ulong access, gn_ulong share, void* sec, gn_ulong disposition, gn_ulong flags, void* template_); +GN_IMPORT int GN_STDCALL WriteFile(void* handle, const void* buf, gn_ulong len, gn_ulong* written, void* overlapped); +GN_IMPORT int GN_STDCALL CloseHandle(void* handle); +GN_IMPORT gn_ulong GN_STDCALL GetEnvironmentVariableA(const char* name, char* buffer, gn_ulong size); +GN_IMPORT void GN_STDCALL OutputDebugStringA(const char* text); +GN_IMPORT void* GN_STDCALL LoadLibraryA(const char* name); +GN_IMPORT void* GN_STDCALL GetProcAddress(void* module, const char* name); +GN_IMPORT unsigned long GN_STDCALL GetLastError(void); +GN_IMPORT long GN_STDCALL CreateDXGIFactory(const void* iid, void** factory); + +typedef int gn_ntstatus; +typedef struct { + gn_uint16 Length; + gn_uint16 MaximumLength; + gn_uint16* Buffer; +} GnUnicodeString; +GN_IMPORT gn_ntstatus GN_STDCALL NtQueryVirtualMemory( + void* process, const void* address, int informationClass, + void* buffer, gn_size length, gn_size* resultLength); +GN_IMPORT gn_ntstatus (GN_STDCALL *__wine_unix_call_dispatcher)( + gn_uint64 handle, unsigned int code, void* args); + + + + + +static gn_size gn_strlen(const char* s) { + gn_size n = 0; + if (!s) return 0; + while (s[n]) ++n; + return n; +} + +static int gn_streq(const char* a, const char* b) { + gn_size i = 0; + if (!a || !b) return 0; + while (a[i] && b[i] && a[i] == b[i]) ++i; + return a[i] == b[i]; +} + +static int gn_starts_with(const char* a, const char* prefix) { + gn_size i = 0; + if (!a || !prefix) return 0; + while (prefix[i]) { + if (a[i] != prefix[i]) return 0; + ++i; + } + return 1; +} + +static int gn_contains(const char* haystack, const char* needle) { + gn_size i = 0; + if (!haystack || !needle || !needle[0]) return 0; + while (haystack[i]) { + gn_size j = 0; + while (needle[j] && haystack[i + j] == needle[j]) ++j; + if (!needle[j]) return 1; + ++i; + } + return 0; +} + +static void gn_copy(char* dst, gn_size dst_size, const char* src) { + gn_size i = 0; + if (!dst || dst_size == 0) return; + if (!src) src = ""; + while (i + 1 < dst_size && src[i]) { + dst[i] = src[i]; + ++i; + } + dst[i] = 0; +} + +static void gn_u64_to_dec(gn_uint64 value, char* out) { + char tmp[24]; + int i = 0; + if (value == 0) { + out[0] = '0'; + out[1] = 0; + return; + } + while (value > 0 && i < 23) { + tmp[i++] = (char)('0' + (value % 10)); + value /= 10; + } + int j = 0; + while (i > 0) out[j++] = tmp[--i]; + out[j] = 0; +} + +static void gn_i64_to_dec(long long value, char* out) { + if (value < 0) { + out[0] = '-'; + gn_u64_to_dec((gn_uint64)(-value), out + 1); + } else { + gn_u64_to_dec((gn_uint64)value, out); + } +} + +static gn_size gn_append(char* dst, gn_size dst_size, gn_size offset, const char* src) { + if (!dst || dst_size == 0 || !src) return offset; + while (offset + 1 < dst_size && *src) dst[offset++] = *src++; + dst[offset] = 0; + return offset; +} + +static gn_size gn_append_i64(char* dst, gn_size dst_size, gn_size offset, long long value) { + char num[24]; + gn_i64_to_dec(value, num); + return gn_append(dst, dst_size, offset, num); +} + + + +#define GN_PARSE_MISSING 0x7fffffffffffffffLL + +static long long gn_parse_i64(const char* text, const char* key, long long fallback) { + gn_size i = 0; + gn_size key_len = gn_strlen(key); + if (!text || !key) return fallback; + while (text[i]) { + if (i == 0 || text[i - 1] == ' ') { + gn_size j = 0; + while (j < key_len && text[i + j] == key[j]) ++j; + if (j == key_len && text[i + j] == '=') { + long long sign = 1; + long long value = 0; + i += j + 1; + if (text[i] == '-') { + sign = -1; + ++i; + } + while (text[i] >= '0' && text[i] <= '9') { + value = value * 10 + (text[i] - '0'); + ++i; + } + return value * sign; + } + } + ++i; + } + return fallback; +} + + +static float gn_parse_micro(const char* text, const char* key, float fallback) { + long long raw = gn_parse_i64(text, key, GN_PARSE_MISSING); + if (raw == GN_PARSE_MISSING) return fallback; + return (float)raw * 1e-6f; +} + +static long long gn_float_to_micro(float value) { + float scaled = value * 1e6f; + if (scaled >= 0.0f) return (long long)(scaled + 0.5f); + return (long long)(scaled - 0.5f); +} + + + + + +#define GN_GENERIC_APPEND 0x0004UL +#define GN_FILE_SHARE_RW 0x3UL +#define GN_OPEN_ALWAYS 4UL +#define GN_FILE_ATTRIBUTE_NORMAL 0x80UL +#define GN_INVALID_HANDLE ((void*)(gn_size)~0ULL) + +static void* gn_log_handle = NULL; +static int gn_log_state = 0; + +static void gn_log_line(const char* line) { + char buf[400]; + gn_size n; + + if (gn_log_state == 0) { + char env[8]; + gn_ulong got = GetEnvironmentVariableA("GAMENATIVE_XR_LOG", env, sizeof(env)); + gn_log_state = (got > 0 && env[0] != '0') ? 1 : -1; + if (gn_log_state == 1) { + gn_log_handle = CreateFileA( + "C:\\gamenative-xr\\runtime.log", + GN_GENERIC_APPEND, + GN_FILE_SHARE_RW, + NULL, + GN_OPEN_ALWAYS, + GN_FILE_ATTRIBUTE_NORMAL, + NULL); + if (gn_log_handle == GN_INVALID_HANDLE) gn_log_handle = NULL; + } + } + + n = gn_append(buf, sizeof(buf), 0, "gamenative-xr: "); + n = gn_append(buf, sizeof(buf), n, line); + OutputDebugStringA(buf); + if (gn_log_handle != NULL) { + gn_ulong written = 0; + n = gn_append(buf, sizeof(buf), n, "\r\n"); + WriteFile(gn_log_handle, buf, (gn_ulong)n, &written, NULL); + } +} + +static void gn_log2(const char* a, const char* b) { + char buf[360]; + gn_size n = gn_append(buf, sizeof(buf), 0, a); + n = gn_append(buf, sizeof(buf), n, b ? b : "(null)"); + gn_log_line(buf); +} + +static void gn_log_num(const char* a, long long value) { + char buf[360]; + gn_size n = gn_append(buf, sizeof(buf), 0, a); + n = gn_append_i64(buf, sizeof(buf), n, value); + gn_log_line(buf); +} + + + + + +#define GN_MAX_PATHS 512 +#define GN_PATH_LEN 160 +#define GN_MAX_ACTION_SETS 32 +#define GN_MAX_ACTIONS 256 +#define GN_MAX_REF_SPACES 32 +#define GN_MAX_ACTION_SPACES 64 + +#ifdef _WIN64 +#define GN_ACTIONSET_BASE 0x4753455400000ULL +#define GN_ACTION_BASE 0x4741435400000ULL +#define GN_REFSPACE_BASE 0x4752455300000ULL +#define GN_ACTSPACE_BASE 0x4741535000000ULL +#define GN_SWAPCHAIN_BASE 0x4753575000000ULL +#else + + +#define GN_ACTIONSET_BASE 0x47500000ULL +#define GN_ACTION_BASE 0x47400000ULL +#define GN_REFSPACE_BASE 0x47600000ULL +#define GN_ACTSPACE_BASE 0x47700000ULL +#define GN_SWAPCHAIN_BASE 0x47800000ULL +#endif +#define GN_HANDLE_IDX_MASK 0xFFFFULL +#define GN_MAX_SWAPCHAINS 32 + + +enum { + GN_COMP_NONE = 0, + GN_COMP_PRIMARY, + GN_COMP_SECONDARY, + GN_COMP_STICK_CLICK, + GN_COMP_MENU, + GN_COMP_TRIGGER, + GN_COMP_SQUEEZE, + GN_COMP_STICK, + GN_COMP_STICK_X, + GN_COMP_STICK_Y, + GN_COMP_GRIP_POSE, + GN_COMP_AIM_POSE, + GN_COMP_HAPTIC, + GN_COMP_COUNT +}; + +typedef struct { + int used; + int attached; + char name[64]; +} GnActionSet; + +typedef struct { + int used; + int action_set_idx; + XrActionType type; + unsigned char component[2]; + unsigned char binding_priority[2]; + unsigned char active_hands; + char name[64]; +} GnAction; + +typedef struct { + int used; + XrReferenceSpaceType type; + XrPosef pose_in_reference_space; +} GnRefSpace; + +typedef struct { + int used; + int action_idx; + int hand; + XrPosef pose_in_action_space; +} GnActionSpace; + +typedef struct { + int active; + unsigned buttons; + float trigger, squeeze, sx, sy; + float grip[7]; + float aim[7]; +} GnHandState; + +typedef struct { + float quat[4]; + float pos[3]; + float fov[4]; +} GnEyeView; + +enum { + GN_IMAGE_AVAILABLE = 0, + GN_IMAGE_ACQUIRED, + GN_IMAGE_WAITED +}; + +typedef struct { + int used; + gn_uint32 image_count; + gn_uint32 next_image; + gn_uint32 acquire_queue[GN_UNIX_MAX_IMAGES]; + gn_uint32 acquire_head; + gn_uint32 acquire_count; + gn_uint32 last_released_image; + int last_released_valid; + unsigned char image_state[GN_UNIX_MAX_IMAGES]; + unsigned char submitted[GN_UNIX_MAX_IMAGES]; + gn_uint64 images[GN_UNIX_MAX_IMAGES]; + void* d3d_images[GN_UNIX_MAX_IMAGES]; + XrSwapchainCreateInfo create_info; +} GnSwapchain; + +static XrInstance gn_instance = (XrInstance)0x474e5852494e5354ULL; +static XrSession gn_session = (XrSession)0x474e585253455353ULL; +static XrSystemId gn_system_id = 1; +static XrTime gn_next_display_time = 1; +static int gn_session_running = 0; +static int gn_stopping_pushed = 0; +static int gn_winsock_started = 0; +static gn_socket gn_bridge_socket = GN_INVALID_SOCKET; +static int gn_bridge_ever_connected = 0; +static int gn_frame_milestone_sent = 0; +static XrSessionState gn_event_states[16]; +static gn_uint32 gn_event_head = 0; +static gn_uint32 gn_event_tail = 0; + +static char gn_paths[GN_MAX_PATHS][GN_PATH_LEN]; +static gn_uint32 gn_path_count = 0; + +static GnActionSet gn_action_sets[GN_MAX_ACTION_SETS]; +static GnAction gn_actions[GN_MAX_ACTIONS]; +static gn_uint32 gn_action_count = 0; +static gn_uint32 gn_action_set_count = 0; +static GnRefSpace gn_ref_spaces[GN_MAX_REF_SPACES]; +static gn_uint32 gn_ref_space_count = 0; +static GnActionSpace gn_action_spaces[GN_MAX_ACTION_SPACES]; +static gn_uint32 gn_action_space_count = 0; + +static GnHandState gn_hands[2]; +static float gn_comp_prev[2][GN_COMP_COUNT]; +static XrTime gn_comp_change_time[2][GN_COMP_COUNT]; +static unsigned char gn_comp_changed[2][GN_COMP_COUNT]; +static XrTime gn_last_sync_time = 0; + +static GnEyeView gn_eye_views[2]; +static int gn_eye_views_valid = 0; +static XrPosef gn_local_origin; +static int gn_local_origin_valid = 0; +static XrPosef gn_last_head_pose; +static XrTime gn_last_head_time = 0; +static float gn_head_linear_velocity[3]; +static float gn_head_angular_velocity[3]; +static XrPosef gn_last_hand_pose[2]; +static XrTime gn_last_hand_time[2]; +static float gn_hand_linear_velocity[2][3]; +static float gn_hand_angular_velocity[2][3]; + +static gn_uint32 gn_view_width = 1440; +static gn_uint32 gn_view_height = 1584; +static int gn_stage_supported = 1; + +static XrPath gn_path_hand_left = 0; +static XrPath gn_path_hand_right = 0; + + +enum { GN_GFX_UNKNOWN = 0, GN_GFX_D3D11, GN_GFX_D3D12, GN_GFX_VULKAN }; +static int gn_gfx_api = GN_GFX_UNKNOWN; +static int gn_action_sets_attached = 0; +static int gn_exit_requested = 0; +static gn_uint32 gn_events_lost = 0; +static int gn_interaction_profile_event_pending = 0; +static int gn_reference_space_event_pending = 0; +static int gn_instance_loss_event_pending = 0; +static GnSwapchain gn_swapchains[GN_MAX_SWAPCHAINS]; +static gn_uint32 gn_swapchain_count = 0; +static gn_uint32 gn_transport_eye_mask = 0; +static int gn_transport_failure_logged = 0; +static gn_uint64 gn_unix_handle = 0; +static int gn_unix_load_attempted = 0; +typedef gn_ntstatus (GN_STDCALL *GnWineUnixCall)(gn_uint32 code, void* args); +static GnWineUnixCall gn_wine_unix_call = NULL; +static VkInstance gn_vk_instance = NULL; +static VkPhysicalDevice gn_vk_physical_device = NULL; +static VkDevice gn_vk_device = NULL; +static VkQueue gn_vk_queue = NULL; +static void* gn_dxvk_interop = NULL; +static void* gn_vkd3d_interop = NULL; +static void* gn_vkd3d_device_ext = NULL; +static ID3D12CommandQueue* gn_d3d12_queue = NULL; + +static int gn_bridge_call(const char* command, char* response, gn_size response_size); +static void gn_identity_pose(XrPosef* pose); +static XrQuaternionf gn_quat_multiply(XrQuaternionf a, XrQuaternionf b); + +static const char* GN_VULKAN_INSTANCE_EXTENSIONS = ""; + + + +static const char* GN_VULKAN_DEVICE_EXTENSIONS = ""; + + + +static volatile int gn_lock = 0; + +static void gn_lock_acquire(void) { + while (__atomic_exchange_n(&gn_lock, 1, __ATOMIC_ACQUIRE) != 0) { +#if defined(__x86_64__) || defined(__i386__) + __builtin_ia32_pause(); +#endif + } +} + +static void gn_lock_release(void) { + __atomic_store_n(&gn_lock, 0, __ATOMIC_RELEASE); +} + +static int gn_load_unixlib(void) { + if (gn_unix_handle) return 1; + if (gn_unix_load_attempted) return 0; + gn_unix_load_attempted = 1; + + + + + { + static gn_uint16 unixlib_name[] = { + 'g','a','m','e','n','a','t','i','v','e','_','x','r','_', + 'u','n','i','x','b','r','i','d','g','e','.','d','l','l',0 + }; + GnUnicodeString name; + gn_uint64 result[2] = {0, 0}; + gn_size result_length = 0; + name.Length = (gn_uint16)(sizeof(unixlib_name) - sizeof(gn_uint16)); + name.MaximumLength = (gn_uint16)sizeof(unixlib_name); + name.Buffer = unixlib_name; + + + gn_ntstatus status = NtQueryVirtualMemory( + (void*)(gn_size)-1, + &name, + 1002, + result, + sizeof(result), + &result_length); + if (status == 0 && result[1]) { + gn_unix_handle = result[1]; + gn_log_line("Wine unixlib loaded directly by name"); + } else { + gn_log_num("Wine direct unixlib load unavailable, status=", status); + } + } + + if (!gn_unix_handle) { + + + void* module = LoadLibraryA("gamenative_xr_unixbridge.dll"); + if (!module) { + gn_log_num("Wine unix bridge module load failed, error=", GetLastError()); + return 0; + } + gn_wine_unix_call = (GnWineUnixCall)GetProcAddress(module, "gnWineUnixCall"); + if (!gn_wine_unix_call) { + gn_log_line("Wine unix bridge entry point missing"); + return 0; + } + gn_unix_handle = (gn_uint64)(gn_size)module; + } + + { + struct gn_unix_init_args args; + args.abi_version = GN_UNIX_ABI_VERSION; + args.result = GN_UNIX_ERROR_UNAVAILABLE; + gn_ntstatus status = gn_wine_unix_call ? + gn_wine_unix_call(GN_UNIX_INIT, &args) : + __wine_unix_call_dispatcher(gn_unix_handle, GN_UNIX_INIT, &args); + if (status != 0 || args.result != GN_UNIX_SUCCESS) { + gn_log_num("Wine unixlib init failed status=", status); + gn_log_num("Wine unixlib init result=", args.result); + gn_unix_handle = 0; + gn_wine_unix_call = NULL; + return 0; + } + } + gn_log_line("Wine unixlib ready"); + return 1; +} + +static int gn_unix_call(unsigned int code, void* args) { + if (!gn_load_unixlib()) return 0; + gn_ntstatus status = gn_wine_unix_call ? + gn_wine_unix_call(code, args) : + __wine_unix_call_dispatcher(gn_unix_handle, code, args); + if (status != 0) { + gn_log_num("Wine unix call failed status=", status); + return 0; + } + return 1; +} + +static int gn_swapchain_index(XrSwapchain swapchain) { + gn_uint64 handle = (gn_uint64)swapchain; + if ((handle & ~GN_HANDLE_IDX_MASK) != GN_SWAPCHAIN_BASE) return -1; + gn_uint64 index = handle & GN_HANDLE_IDX_MASK; + if (index >= gn_swapchain_count || !gn_swapchains[index].used) return -1; + return (int)index; +} + +typedef VkResult (GN_STDCALL *GnVkEnumeratePhysicalDevices)( + VkInstance instance, gn_uint32* count, VkPhysicalDevice* devices); +typedef void (GN_STDCALL *GnVkGetDeviceQueue)( + VkDevice device, gn_uint32 family, gn_uint32 index, VkQueue* queue); + +static void* gn_vulkan_proc(const char* name) { + static void* module = NULL; + if (!module) module = LoadLibraryA("vulkan-1.dll"); + return module ? GetProcAddress(module, name) : NULL; +} + +static VkPhysicalDevice gn_first_vulkan_physical_device(VkInstance instance) { + GnVkEnumeratePhysicalDevices enumerate = + (GnVkEnumeratePhysicalDevices)gn_vulkan_proc("vkEnumeratePhysicalDevices"); + VkPhysicalDevice devices[16]; + gn_uint32 count = 16; + if (!enumerate || enumerate(instance, &count, devices) != 0 || count == 0) return NULL; + return devices[0]; +} + +static int gn_set_vulkan_context(const XrGraphicsBindingVulkanKHR* binding) { + GnVkGetDeviceQueue get_queue = + (GnVkGetDeviceQueue)gn_vulkan_proc("vkGetDeviceQueue"); + if (!binding || !get_queue) return 0; + gn_vk_physical_device = binding->physicalDevice; + gn_vk_device = binding->device; + get_queue(binding->device, binding->queueFamilyIndex, binding->queueIndex, &gn_vk_queue); + if (!gn_vk_physical_device || !gn_vk_device || !gn_vk_queue) return 0; + + struct gn_unix_vulkan_context_args args; + args.client_physical_device = (gn_u64)gn_vk_physical_device; + args.client_device = (gn_u64)gn_vk_device; + args.client_queue = (gn_u64)gn_vk_queue; + args.queue_family_index = binding->queueFamilyIndex; + args.queue_index = binding->queueIndex; + args.handles_are_host = 0; + args.diagnostic_flags = 0; + args.result = GN_UNIX_ERROR_UNAVAILABLE; + if (!gn_unix_call(GN_UNIX_SET_VULKAN_CONTEXT, &args) || + args.result != GN_UNIX_SUCCESS) { + gn_log_num("Wine Vulkan context result=", args.result); + gn_log_num("Wine Vulkan context flags=", args.diagnostic_flags); + return 0; + } + return 1; +} + +typedef long (GN_STDCALL *GnComQueryInterface)(void*, const GnGuid*, void**); +typedef unsigned long (GN_STDCALL *GnComRelease)(void*); +typedef void (GN_STDCALL *GnDxvkGetVulkanHandles)( + void*, VkInstance*, VkPhysicalDevice*, VkDevice*); +typedef void (GN_STDCALL *GnDxvkGetSubmissionQueue1)( + void*, VkQueue*, gn_uint32*, gn_uint32*); +typedef void (GN_STDCALL *GnDxvkVoidCall)(void*); +typedef long (GN_STDCALL *GnDxvkCreateTexture)( + void*, const GnD3D11Texture2DDesc1*, VkImage, ID3D11Texture2D**); + +static void* gn_com_method(void* object, int index) { + if (!object) return NULL; + return (*(void***)object)[index]; +} + +static void gn_com_release(void* object) { + GnComRelease release = (GnComRelease)gn_com_method(object, 2); + if (release) release(object); +} + +typedef struct GnDxgiAdapterDesc { + gn_uint16 Description[128]; + gn_uint32 VendorId; + gn_uint32 DeviceId; + gn_uint32 SubSysId; + gn_uint32 Revision; + gn_size DedicatedVideoMemory; + gn_size DedicatedSystemMemory; + gn_size SharedSystemMemory; + LUID AdapterLuid; +} GnDxgiAdapterDesc; + +typedef long (GN_STDCALL *GnDxgiEnumAdapters)(void*, gn_uint32, void**); +typedef long (GN_STDCALL *GnDxgiGetDesc)(void*, GnDxgiAdapterDesc*); + +static LUID gn_primary_adapter_luid(void) { + static int queried = 0; + static LUID cached = {1, 0}; + if (queried) return cached; + queried = 1; + static const GnGuid iid_factory = { + 0x7b7166ec, 0x21c7, 0x44ae, + {0xb2,0x1a,0xc9,0xae,0x32,0x1a,0xe3,0x69} + }; + void* factory = NULL; + void* adapter = NULL; + if (CreateDXGIFactory(&iid_factory, &factory) >= 0 && factory) { + GnDxgiEnumAdapters enumerate = + (GnDxgiEnumAdapters)gn_com_method(factory, 7); + if (enumerate && enumerate(factory, 0, &adapter) >= 0 && adapter) { + GnDxgiAdapterDesc desc; + GnDxgiGetDesc get_desc = + (GnDxgiGetDesc)gn_com_method(adapter, 8); + if (get_desc && get_desc(adapter, &desc) >= 0) { + cached = desc.AdapterLuid; + if (!cached.LowPart && !cached.HighPart) cached.LowPart = 1; + } + gn_com_release(adapter); + } + gn_com_release(factory); + } + return cached; +} + +static int gn_set_d3d11_context(ID3D11Device* device11) { + static const GnGuid iid_interop1 = { + 0xe2ef5fa5, 0xdc21, 0x4af7, + {0x90,0xc4,0xf6,0x7e,0xf6,0xa0,0x93,0x24} + }; + GnComQueryInterface query = (GnComQueryInterface)gn_com_method(device11, 0); + if (!query || query(device11, &iid_interop1, &gn_dxvk_interop) < 0 || + !gn_dxvk_interop) { + gn_log_line("DXVK IDXGIVkInteropDevice1 unavailable"); + return 0; + } + + VkInstance instance = NULL; + gn_uint32 queue_family = 0; + gn_uint32 queue_index = 0; + GnDxvkGetVulkanHandles get_handles = + (GnDxvkGetVulkanHandles)gn_com_method(gn_dxvk_interop, 3); + GnDxvkGetSubmissionQueue1 get_queue = + (GnDxvkGetSubmissionQueue1)gn_com_method(gn_dxvk_interop, 9); + if (!get_handles || !get_queue) return 0; + get_handles(gn_dxvk_interop, &instance, &gn_vk_physical_device, &gn_vk_device); + get_queue(gn_dxvk_interop, &gn_vk_queue, &queue_index, &queue_family); + if (!gn_vk_physical_device || !gn_vk_device || !gn_vk_queue) return 0; + + struct gn_unix_vulkan_context_args args; + args.client_physical_device = (gn_u64)gn_vk_physical_device; + args.client_device = (gn_u64)gn_vk_device; + args.client_queue = (gn_u64)gn_vk_queue; + args.queue_family_index = queue_family; + args.queue_index = queue_index; + + + + args.handles_are_host = 0; + args.diagnostic_flags = 0; + args.result = GN_UNIX_ERROR_UNAVAILABLE; + if (!gn_unix_call(GN_UNIX_SET_VULKAN_CONTEXT, &args) || + args.result != GN_UNIX_SUCCESS) { + gn_log_num("Wine DXVK Vulkan context result=", args.result); + gn_log_num("Wine DXVK Vulkan context flags=", args.diagnostic_flags); + return 0; + } + return 1; +} + +static void gn_dxvk_flush_and_lock(void) { + GnDxvkVoidCall flush = + (GnDxvkVoidCall)gn_com_method(gn_dxvk_interop, 6); + GnDxvkVoidCall lock = + (GnDxvkVoidCall)gn_com_method(gn_dxvk_interop, 7); + if (flush) flush(gn_dxvk_interop); + if (lock) lock(gn_dxvk_interop); +} + +static void gn_dxvk_unlock(void) { + GnDxvkVoidCall unlock = + (GnDxvkVoidCall)gn_com_method(gn_dxvk_interop, 8); + if (unlock) unlock(gn_dxvk_interop); +} + +typedef long (GN_STDCALL *GnVkd3dGetVulkanHandles)( + void*, VkInstance*, VkPhysicalDevice*, VkDevice*); +typedef long (GN_STDCALL *GnVkd3dGetQueueInfoEx)( + void*, ID3D12CommandQueue*, VkQueue*, gn_uint32*, gn_uint32*, gn_uint32*); +typedef long (GN_STDCALL *GnVkd3dQueueCall)( + void*, ID3D12CommandQueue*); +typedef long (GN_STDCALL *GnVkd3dCreateResource)( + void*, const GnD3D12ResourceDesc1*, gn_uint64, ID3D12Resource**); + +static int gn_set_d3d12_context( + ID3D12Device* device12, ID3D12CommandQueue* queue12) { + static const GnGuid iid_interop = { + 0x39da4e09, 0xbd1c, 0x4198, + {0x9f,0xae,0x86,0xbb,0xe3,0xbe,0x41,0xfd} + }; + static const GnGuid iid_device_ext1 = { + 0x099a73fd, 0x2199, 0x4f45, + {0xbf,0x48,0x0e,0xb8,0x6f,0x6f,0xdb,0x65} + }; + GnComQueryInterface query = + (GnComQueryInterface)gn_com_method(device12, 0); + if (!query || + query(device12, &iid_interop, &gn_vkd3d_interop) < 0 || + query(device12, &iid_device_ext1, &gn_vkd3d_device_ext) < 0 || + !gn_vkd3d_interop || !gn_vkd3d_device_ext) { + gn_log_line("vkd3d-proton native interop unavailable"); + return 0; + } + + VkInstance instance = NULL; + gn_uint32 queue_index = 0; + gn_uint32 queue_flags = 0; + gn_uint32 queue_family = 0; + GnVkd3dGetVulkanHandles get_handles = + (GnVkd3dGetVulkanHandles)gn_com_method(gn_vkd3d_interop, 7); + GnVkd3dGetQueueInfoEx get_queue = + (GnVkd3dGetQueueInfoEx)gn_com_method(gn_vkd3d_device_ext, 11); + if (!get_handles || !get_queue || + get_handles(gn_vkd3d_interop, &instance, + &gn_vk_physical_device, &gn_vk_device) < 0 || + get_queue(gn_vkd3d_device_ext, queue12, &gn_vk_queue, + &queue_index, &queue_flags, &queue_family) < 0) { + return 0; + } + gn_d3d12_queue = queue12; + struct gn_unix_vulkan_context_args args; + args.client_physical_device = (gn_u64)gn_vk_physical_device; + args.client_device = (gn_u64)gn_vk_device; + args.client_queue = (gn_u64)gn_vk_queue; + args.queue_family_index = queue_family; + args.queue_index = queue_index; + + args.handles_are_host = 0; + args.diagnostic_flags = 0; + args.result = GN_UNIX_ERROR_UNAVAILABLE; + if (!gn_unix_call(GN_UNIX_SET_VULKAN_CONTEXT, &args) || + args.result != GN_UNIX_SUCCESS) { + gn_log_num("Wine vkd3d Vulkan context result=", args.result); + gn_log_num("Wine vkd3d Vulkan context flags=", args.diagnostic_flags); + return 0; + } + return 1; +} + +static void gn_vkd3d_lock(void) { + GnVkd3dQueueCall lock = + (GnVkd3dQueueCall)gn_com_method(gn_vkd3d_interop, 11); + if (lock) lock(gn_vkd3d_interop, gn_d3d12_queue); +} + +static void gn_vkd3d_unlock(void) { + GnVkd3dQueueCall unlock = + (GnVkd3dQueueCall)gn_com_method(gn_vkd3d_interop, 12); + if (unlock) unlock(gn_vkd3d_interop, gn_d3d12_queue); +} + +static int64_t gn_d3d_format_to_vk(int64_t format) { + switch (format) { + case 29: return 43; + case 28: return 37; + case 91: return 50; + case 87: return 44; + default: return 0; + } +} + + + + + +static void gn_push_session_event(XrSessionState state) { + gn_uint32 next_tail = (gn_event_tail + 1) % 16; + if (next_tail == gn_event_head) { + gn_event_head = (gn_event_head + 1) % 16; + ++gn_events_lost; + } + gn_event_states[gn_event_tail] = state; + gn_event_tail = next_tail; +} + +static int gn_pop_session_event(XrSessionState* state) { + if (gn_event_head == gn_event_tail || state == NULL) return 0; + *state = gn_event_states[gn_event_head]; + gn_event_head = (gn_event_head + 1) % 16; + return 1; +} + +static void gn_clear_events(void) { + gn_event_head = 0; + gn_event_tail = 0; + gn_events_lost = 0; + gn_interaction_profile_event_pending = 0; + gn_reference_space_event_pending = 0; + gn_instance_loss_event_pending = 0; +} + + + + + +static XrResult gn_fill_string(const char* src, gn_uint32 capacity, gn_uint32* count, char* dst) { + gn_uint32 needed = (gn_uint32)gn_strlen(src) + 1; + if (count) *count = needed; + if (capacity == 0) return XR_SUCCESS; + if (!dst || capacity < needed) return XR_ERROR_SIZE_INSUFFICIENT; + gn_copy(dst, capacity, src); + return XR_SUCCESS; +} + +static XrResult gn_copy_props(gn_uint32 available, gn_uint32 capacity, gn_uint32* count) { + if (count) *count = available; + if (capacity != 0 && capacity < available) return XR_ERROR_SIZE_INSUFFICIENT; + return XR_SUCCESS; +} + +static void gn_write_extension(XrExtensionProperties* property, const char* name, gn_uint32 version) { + property->type = XR_TYPE_EXTENSION_PROPERTIES; + property->next = NULL; + gn_copy(property->extensionName, XR_MAX_EXTENSION_NAME_SIZE, name); + property->extensionVersion = version; +} + + + + + +static void gn_bridge_close(void) { + if (gn_bridge_socket != GN_INVALID_SOCKET) { + closesocket(gn_bridge_socket); + gn_bridge_socket = GN_INVALID_SOCKET; + } +} + +static int gn_bridge_connect_locked(void) { + struct gn_wsadata wsa; + struct gn_sockaddr_in addr; + + if (gn_bridge_socket != GN_INVALID_SOCKET) return 1; + if (!gn_winsock_started) { + if (WSAStartup(0x0202, &wsa) != 0) { + gn_log_line("WSAStartup failed"); + return 0; + } + gn_winsock_started = 1; + } + + gn_bridge_socket = socket(GN_AF_INET, GN_SOCK_STREAM, GN_IPPROTO_TCP); + if (gn_bridge_socket == GN_INVALID_SOCKET) { + gn_log_line("socket() failed"); + return 0; + } + + addr.sin_family = GN_AF_INET; + addr.sin_port = htons(38476); + addr.sin_addr.s_addr = inet_addr("127.0.0.1"); + for (gn_size i = 0; i < sizeof(addr.sin_zero); ++i) addr.sin_zero[i] = 0; + + if (connect(gn_bridge_socket, &addr, sizeof(addr)) == GN_SOCKET_ERROR) { + gn_bridge_close(); + gn_log_line("connect to 127.0.0.1:38476 failed (is XrBridgeServer running?)"); + return 0; + } + return 1; +} + + +static int gn_bridge_call_locked(const char* command, char* response, gn_size response_size) { + char local_response[192]; + char* out = response; + gn_size out_size = response_size; + char ch = 0; + gn_size offset = 0; + gn_size len = gn_strlen(command); + int got = 0; + + if (out == NULL || out_size == 0) { + out = local_response; + out_size = sizeof(local_response); + } + out[0] = 0; + if (gn_bridge_socket == GN_INVALID_SOCKET) { + if (!gn_bridge_connect_locked()) return 0; + + { + char hello[64]; + const char* h = "HELLO\n"; + if (send(gn_bridge_socket, h, 6, 0) == GN_SOCKET_ERROR) { + gn_bridge_close(); + return 0; + } + gn_size hoff = 0; + while (hoff + 1 < sizeof(hello)) { + if (recv(gn_bridge_socket, &ch, 1, 0) <= 0) { + gn_bridge_close(); + return 0; + } + if (ch == '\n') break; + hello[hoff++] = ch; + } + hello[hoff] = 0; + if (!gn_starts_with(hello, "OK")) { + gn_bridge_close(); + gn_log2("bridge HELLO rejected: ", hello); + return 0; + } + if (!gn_bridge_ever_connected) { + gn_bridge_ever_connected = 1; + gn_log2("bridge connected: ", hello); + } + } + if (gn_streq(command, "HELLO")) { + gn_copy(out, out_size, "OK GameNativeVR"); + return 1; + } + } + if (send(gn_bridge_socket, command, (int)len, 0) == GN_SOCKET_ERROR || + send(gn_bridge_socket, "\n", 1, 0) == GN_SOCKET_ERROR) { + gn_bridge_close(); + gn_log2("bridge send failed for: ", command); + return 0; + } + + while (offset + 1 < out_size) { + got = recv(gn_bridge_socket, &ch, 1, 0); + if (got <= 0) { + gn_bridge_close(); + gn_log2("bridge recv failed for: ", command); + return 0; + } + if (ch == '\n') break; + out[offset++] = ch; + } + out[offset] = 0; + return gn_starts_with(out, "OK"); +} + +static int gn_bridge_call(const char* command, char* response, gn_size response_size) { + int ok; + gn_lock_acquire(); + ok = gn_bridge_call_locked(command, response, response_size); + gn_lock_release(); + return ok; +} + + + + + +static XrPath gn_path_get_or_create(const char* str) { + gn_uint32 i; + if (!str || !str[0]) return XR_NULL_PATH; + for (i = 0; i < gn_path_count; ++i) { + if (gn_streq(gn_paths[i], str)) return (XrPath)(i + 1); + } + if (gn_path_count >= GN_MAX_PATHS) return XR_NULL_PATH; + gn_copy(gn_paths[gn_path_count], GN_PATH_LEN, str); + ++gn_path_count; + return (XrPath)gn_path_count; +} + +static const char* gn_path_string(XrPath path) { + gn_uint64 idx = (gn_uint64)path; + if (idx == 0 || idx > gn_path_count) return NULL; + return gn_paths[idx - 1]; +} + +static void gn_paths_init(void) { + if (gn_path_hand_left == 0) { + gn_path_hand_left = gn_path_get_or_create("/user/hand/left"); + gn_path_hand_right = gn_path_get_or_create("/user/hand/right"); + } +} + + +static int gn_hand_from_path(XrPath path) { + const char* str; + if (path == XR_NULL_PATH) return -1; + if (path == gn_path_hand_left) return 0; + if (path == gn_path_hand_right) return 1; + str = gn_path_string(path); + if (!str) return -1; + if (gn_starts_with(str, "/user/hand/left")) return 0; + if (gn_starts_with(str, "/user/hand/right")) return 1; + return -1; +} + + +static int gn_component_from_binding(const char* str) { + if (!str) return GN_COMP_NONE; + if (gn_contains(str, "/output/haptic")) return GN_COMP_HAPTIC; + if (gn_contains(str, "/input/grip")) return GN_COMP_GRIP_POSE; + if (gn_contains(str, "/input/aim")) return GN_COMP_AIM_POSE; + if (gn_contains(str, "/input/trigger")) return GN_COMP_TRIGGER; + if (gn_contains(str, "/input/squeeze")) return GN_COMP_SQUEEZE; + if (gn_contains(str, "/input/thumbstick/click")) return GN_COMP_STICK_CLICK; + if (gn_contains(str, "/input/thumbstick/x")) return GN_COMP_STICK_X; + if (gn_contains(str, "/input/thumbstick/y")) return GN_COMP_STICK_Y; + if (gn_contains(str, "/input/thumbstick")) return GN_COMP_STICK; + if (gn_contains(str, "/input/joystick")) return GN_COMP_STICK; + if (gn_contains(str, "/input/a/")) return GN_COMP_PRIMARY; + if (gn_contains(str, "/input/x/")) return GN_COMP_PRIMARY; + if (gn_contains(str, "/input/b/")) return GN_COMP_SECONDARY; + if (gn_contains(str, "/input/y/")) return GN_COMP_SECONDARY; + if (gn_contains(str, "/input/menu")) return GN_COMP_MENU; + if (gn_contains(str, "/input/system")) return GN_COMP_MENU; + if (gn_contains(str, "/input/select")) return GN_COMP_TRIGGER; + return GN_COMP_NONE; +} + + + +static int gn_interaction_profile_priority(const char* profile) { + if (!profile) return 0; + if (gn_streq(profile, "/interaction_profiles/oculus/touch_controller")) return 100; + if (gn_streq(profile, "/interaction_profiles/meta/touch_controller_plus")) return 100; + if (gn_streq(profile, "/interaction_profiles/khr/simple_controller")) return 10; + return 1; +} + + + + + +static int gn_action_index(XrAction action) { + gn_uint64 h = (gn_uint64)action; + if ((h & ~GN_HANDLE_IDX_MASK) != GN_ACTION_BASE) return -1; + gn_uint64 idx = h & GN_HANDLE_IDX_MASK; + if (idx >= gn_action_count || !gn_actions[idx].used) return -1; + return (int)idx; +} + +static int gn_action_set_index(XrActionSet action_set) { + gn_uint64 h = (gn_uint64)action_set; + if ((h & ~GN_HANDLE_IDX_MASK) != GN_ACTIONSET_BASE) return -1; + gn_uint64 idx = h & GN_HANDLE_IDX_MASK; + if (idx >= gn_action_set_count || !gn_action_sets[idx].used) return -1; + return (int)idx; +} + +static int gn_ref_space_index(XrSpace space) { + gn_uint64 h = (gn_uint64)space; + if ((h & ~GN_HANDLE_IDX_MASK) != GN_REFSPACE_BASE) return -1; + gn_uint64 idx = h & GN_HANDLE_IDX_MASK; + if (idx >= gn_ref_space_count || !gn_ref_spaces[idx].used) return -1; + return (int)idx; +} + +static int gn_action_space_index(XrSpace space) { + gn_uint64 h = (gn_uint64)space; + if ((h & ~GN_HANDLE_IDX_MASK) != GN_ACTSPACE_BASE) return -1; + gn_uint64 idx = h & GN_HANDLE_IDX_MASK; + if (idx >= gn_action_space_count || !gn_action_spaces[idx].used) return -1; + return (int)idx; +} + + +static int gn_action_default_hand(const GnAction* action) { + if (action->component[0] != GN_COMP_NONE) return 0; + if (action->component[1] != GN_COMP_NONE) return 1; + return 0; +} + + + + + +static float gn_comp_value(int hand, int comp) { + const GnHandState* h = &gn_hands[hand]; + switch (comp) { + case GN_COMP_PRIMARY: return (h->buttons & 1u) ? 1.0f : 0.0f; + case GN_COMP_SECONDARY: return (h->buttons & 2u) ? 1.0f : 0.0f; + case GN_COMP_STICK_CLICK: return (h->buttons & 4u) ? 1.0f : 0.0f; + case GN_COMP_MENU: return (h->buttons & 8u) ? 1.0f : 0.0f; + case GN_COMP_TRIGGER: return h->trigger; + case GN_COMP_SQUEEZE: return h->squeeze; + case GN_COMP_STICK_X: return h->sx; + case GN_COMP_STICK_Y: return h->sy; + case GN_COMP_STICK: return h->sx; + default: return 0.0f; + } +} + +static void gn_refresh_hand(int hand) { + char cmd[32]; + char response[512]; + gn_size n; + GnHandState* h = &gn_hands[hand]; + + n = gn_append(cmd, sizeof(cmd), 0, "GET_INPUT hand="); + n = gn_append_i64(cmd, sizeof(cmd), n, hand); + if (!gn_bridge_call(cmd, response, sizeof(response))) { + h->active = 0; + return; + } + + h->active = (int)gn_parse_i64(response, "active", 0); + h->buttons = (unsigned)gn_parse_i64(response, "buttons", 0); + h->trigger = gn_parse_micro(response, "tr", 0.0f); + h->squeeze = gn_parse_micro(response, "sq", 0.0f); + h->sx = gn_parse_micro(response, "sx", 0.0f); + h->sy = gn_parse_micro(response, "sy", 0.0f); + + h->grip[0] = gn_parse_micro(response, "gqx", 0.0f); + h->grip[1] = gn_parse_micro(response, "gqy", 0.0f); + h->grip[2] = gn_parse_micro(response, "gqz", 0.0f); + h->grip[3] = gn_parse_micro(response, "gqw", 1.0f); + h->grip[4] = gn_parse_micro(response, "gpx", 0.0f); + h->grip[5] = gn_parse_micro(response, "gpy", 0.0f); + h->grip[6] = gn_parse_micro(response, "gpz", 0.0f); + + h->aim[0] = gn_parse_micro(response, "aqx", 0.0f); + h->aim[1] = gn_parse_micro(response, "aqy", 0.0f); + h->aim[2] = gn_parse_micro(response, "aqz", 0.0f); + h->aim[3] = gn_parse_micro(response, "aqw", 1.0f); + h->aim[4] = gn_parse_micro(response, "apx", 0.0f); + h->aim[5] = gn_parse_micro(response, "apy", 0.0f); + h->aim[6] = gn_parse_micro(response, "apz", 0.0f); +} + +static void gn_update_change_tracking(XrTime sync_time) { + for (int hand = 0; hand < 2; ++hand) { + for (int comp = 1; comp < GN_COMP_COUNT; ++comp) { + float value = gn_comp_value(hand, comp); + float prev = gn_comp_prev[hand][comp]; + float delta = value - prev; + if (delta < 0.0f) delta = -delta; + if (delta > 0.0001f) { + gn_comp_changed[hand][comp] = 1; + gn_comp_change_time[hand][comp] = sync_time; + } else { + gn_comp_changed[hand][comp] = 0; + } + gn_comp_prev[hand][comp] = value; + } + } + gn_last_sync_time = sync_time; +} + +static void gn_write_pose(XrPosef* pose, const float* data) { + pose->orientation.x = data[0]; + pose->orientation.y = data[1]; + pose->orientation.z = data[2]; + pose->orientation.w = data[3]; + pose->position.x = data[4]; + pose->position.y = data[5]; + pose->position.z = data[6]; +} + +static void gn_update_pose_velocity( + const XrPosef* pose, + XrTime time, + XrPosef* previous, + XrTime* previous_time, + float linear[3], + float angular[3], + int detect_recenter) { + for (int i = 0; i < 3; ++i) { + linear[i] = 0.0f; + angular[i] = 0.0f; + } + if (*previous_time > 0 && time > *previous_time) { + float dt = (float)(time - *previous_time) * 1e-9f; + float dx = pose->position.x - previous->position.x; + float dy = pose->position.y - previous->position.y; + float dz = pose->position.z - previous->position.z; + float orientation_dot = + pose->orientation.x * previous->orientation.x + + pose->orientation.y * previous->orientation.y + + pose->orientation.z * previous->orientation.z + + pose->orientation.w * previous->orientation.w; + if (orientation_dot < 0.0f) orientation_dot = -orientation_dot; + if (detect_recenter && + (dx * dx + dy * dy + dz * dz > 0.64f || + orientation_dot < 0.9238795f)) { + gn_reference_space_event_pending = 1; + + + gn_local_origin = *pose; + *previous = *pose; + *previous_time = time; + return; + } + if (dt > 0.00001f && dt < 0.5f) { + XrQuaternionf previous_inverse = { + -previous->orientation.x, + -previous->orientation.y, + -previous->orientation.z, + previous->orientation.w, + }; + XrQuaternionf delta = gn_quat_multiply(pose->orientation, previous_inverse); + if (delta.w < 0.0f) { + delta.x = -delta.x; + delta.y = -delta.y; + delta.z = -delta.z; + } + linear[0] = dx / dt; + linear[1] = dy / dt; + linear[2] = dz / dt; + angular[0] = 2.0f * delta.x / dt; + angular[1] = 2.0f * delta.y / dt; + angular[2] = 2.0f * delta.z / dt; + } + } + *previous = *pose; + *previous_time = time; +} + + + + + +static XrResult XRAPI_CALL gn_xrEnumerateInstanceExtensionProperties( + const char* layerName, + gn_uint32 propertyCapacityInput, + gn_uint32* propertyCountOutput, + XrExtensionProperties* properties) { + (void)layerName; + const gn_uint32 available = 4; + if (!propertyCountOutput) return XR_ERROR_VALIDATION_FAILURE; + if (propertyCapacityInput != 0 && properties == NULL) return XR_ERROR_VALIDATION_FAILURE; + XrResult r = gn_copy_props(available, propertyCapacityInput, propertyCountOutput); + if (XR_FAILED(r) || propertyCapacityInput == 0) return r; + gn_write_extension(&properties[0], XR_KHR_D3D11_ENABLE_EXTENSION_NAME, XR_KHR_D3D11_enable_SPEC_VERSION); + if (propertyCapacityInput > 1) { + gn_write_extension(&properties[1], XR_KHR_VULKAN_ENABLE_EXTENSION_NAME, XR_KHR_vulkan_enable_SPEC_VERSION); + } + if (propertyCapacityInput > 2) { + gn_write_extension(&properties[2], XR_KHR_VULKAN_ENABLE2_EXTENSION_NAME, XR_KHR_vulkan_enable2_SPEC_VERSION); + } + if (propertyCapacityInput > 3) { + gn_write_extension(&properties[3], XR_KHR_D3D12_ENABLE_EXTENSION_NAME, XR_KHR_D3D12_enable_SPEC_VERSION); + } + return XR_SUCCESS; +} + +static XrResult XRAPI_CALL gn_xrCreateInstance(const XrInstanceCreateInfo* createInfo, XrInstance* instance) { + if (!instance) return XR_ERROR_VALIDATION_FAILURE; + gn_clear_events(); + gn_session_running = 0; + gn_stopping_pushed = 0; + gn_action_sets_attached = 0; + gn_exit_requested = 0; + gn_local_origin_valid = 0; + gn_vk_instance = NULL; + gn_vk_physical_device = NULL; + gn_vk_device = NULL; + gn_vk_queue = NULL; + gn_paths_init(); + if (createInfo) { + gn_log2("xrCreateInstance app=", createInfo->applicationInfo.applicationName); + for (gn_uint32 i = 0; i < createInfo->enabledExtensionCount; ++i) { + gn_log2(" enabled extension: ", createInfo->enabledExtensionNames[i]); + } + } + gn_bridge_call("HELLO", NULL, 0); + *instance = gn_instance; + return XR_SUCCESS; +} + +static XrResult XRAPI_CALL gn_xrDestroyInstance(XrInstance instance) { + (void)instance; + gn_log_line("xrDestroyInstance"); + gn_bridge_call("BYE", NULL, 0); + gn_lock_acquire(); + gn_bridge_close(); + gn_lock_release(); + return XR_SUCCESS; +} + +static XrResult XRAPI_CALL gn_xrGetInstanceProperties(XrInstance instance, XrInstanceProperties* properties) { + (void)instance; + if (!properties) return XR_ERROR_VALIDATION_FAILURE; + properties->runtimeVersion = XR_MAKE_VERSION(0, 2, 0); + gn_copy(properties->runtimeName, XR_MAX_RUNTIME_NAME_SIZE, "GameNativeVR OpenXR Runtime"); + return XR_SUCCESS; +} + +static XrResult XRAPI_CALL gn_xrPollEvent(XrInstance instance, XrEventDataBuffer* eventData) { + XrSessionState state; + if (instance != gn_instance) return XR_ERROR_HANDLE_INVALID; + if (!eventData) return XR_ERROR_VALIDATION_FAILURE; + if (gn_events_lost != 0) { + XrEventDataEventsLost* lost = (XrEventDataEventsLost*)eventData; + lost->type = XR_TYPE_EVENT_DATA_EVENTS_LOST; + lost->next = NULL; + lost->lostEventCount = gn_events_lost; + gn_events_lost = 0; + return XR_SUCCESS; + } + if (gn_instance_loss_event_pending) { + XrEventDataInstanceLossPending* loss = (XrEventDataInstanceLossPending*)eventData; + loss->type = XR_TYPE_EVENT_DATA_INSTANCE_LOSS_PENDING; + loss->next = NULL; + loss->lossTime = gn_next_display_time; + gn_instance_loss_event_pending = 0; + return XR_SUCCESS; + } + if (gn_reference_space_event_pending) { + XrEventDataReferenceSpaceChangePending* change = + (XrEventDataReferenceSpaceChangePending*)eventData; + change->type = XR_TYPE_EVENT_DATA_REFERENCE_SPACE_CHANGE_PENDING; + change->next = NULL; + change->session = gn_session; + change->referenceSpaceType = XR_REFERENCE_SPACE_TYPE_LOCAL; + change->changeTime = gn_next_display_time; + change->poseValid = XR_FALSE; + gn_identity_pose(&change->poseInPreviousSpace); + gn_reference_space_event_pending = 0; + return XR_SUCCESS; + } + if (gn_interaction_profile_event_pending) { + XrEventDataInteractionProfileChanged* changed = + (XrEventDataInteractionProfileChanged*)eventData; + changed->type = XR_TYPE_EVENT_DATA_INTERACTION_PROFILE_CHANGED; + changed->next = NULL; + changed->session = gn_session; + gn_interaction_profile_event_pending = 0; + return XR_SUCCESS; + } + if (gn_pop_session_event(&state)) { + XrEventDataSessionStateChanged* changed = (XrEventDataSessionStateChanged*)eventData; + changed->type = XR_TYPE_EVENT_DATA_SESSION_STATE_CHANGED; + changed->next = NULL; + changed->session = gn_session; + changed->state = state; + changed->time = gn_next_display_time; + gn_log_num("session state event -> ", (long long)state); + return XR_SUCCESS; + } + return XR_EVENT_UNAVAILABLE; +} + +static XrResult XRAPI_CALL gn_xrResultToString(XrInstance instance, XrResult value, char buffer[XR_MAX_RESULT_STRING_SIZE]) { + (void)instance; + char out[XR_MAX_RESULT_STRING_SIZE]; + gn_size n = gn_append(out, sizeof(out), 0, "XR_RESULT_"); + gn_append_i64(out, sizeof(out), n, (long long)value); + gn_copy(buffer, XR_MAX_RESULT_STRING_SIZE, out); + return XR_SUCCESS; +} + +static XrResult XRAPI_CALL gn_xrStructureTypeToString(XrInstance instance, XrStructureType value, char buffer[XR_MAX_STRUCTURE_NAME_SIZE]) { + (void)instance; + (void)value; + gn_copy(buffer, XR_MAX_STRUCTURE_NAME_SIZE, "XR_STRUCTURE_TYPE"); + return XR_SUCCESS; +} + +static XrResult XRAPI_CALL gn_xrGetSystem(XrInstance instance, const XrSystemGetInfo* getInfo, XrSystemId* systemId) { + (void)instance; + if (!getInfo || !systemId) return XR_ERROR_VALIDATION_FAILURE; + if (getInfo->formFactor != XR_FORM_FACTOR_HEAD_MOUNTED_DISPLAY) return XR_ERROR_FORM_FACTOR_UNAVAILABLE; + *systemId = gn_system_id; + return XR_SUCCESS; +} + +static XrResult XRAPI_CALL gn_xrGetSystemProperties(XrInstance instance, XrSystemId systemId, XrSystemProperties* properties) { + (void)instance; + char response[128]; + if (systemId != gn_system_id || !properties) return XR_ERROR_VALIDATION_FAILURE; + gn_bridge_call("GET_SYSTEM", response, sizeof(response)); + properties->systemId = gn_system_id; + properties->vendorId = 0x474e; + gn_copy(properties->systemName, XR_MAX_SYSTEM_NAME_SIZE, "Meta Quest via GameNativeVR"); + properties->graphicsProperties.maxSwapchainImageHeight = 4096; + properties->graphicsProperties.maxSwapchainImageWidth = 4096; + properties->graphicsProperties.maxLayerCount = 16; + properties->trackingProperties.orientationTracking = XR_TRUE; + properties->trackingProperties.positionTracking = XR_TRUE; + return XR_SUCCESS; +} + +static XrResult XRAPI_CALL gn_xrEnumerateEnvironmentBlendModes( + XrInstance instance, + XrSystemId systemId, + XrViewConfigurationType viewConfigurationType, + gn_uint32 capacity, + gn_uint32* count, + XrEnvironmentBlendMode* modes) { + (void)instance; + if (systemId != gn_system_id || viewConfigurationType != XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO) { + return XR_ERROR_VIEW_CONFIGURATION_TYPE_UNSUPPORTED; + } + XrResult r = gn_copy_props(1, capacity, count); + if (XR_FAILED(r) || capacity == 0) return r; + modes[0] = XR_ENVIRONMENT_BLEND_MODE_OPAQUE; + return XR_SUCCESS; +} + +static XrResult XRAPI_CALL gn_xrEnumerateViewConfigurations( + XrInstance instance, + XrSystemId systemId, + gn_uint32 capacity, + gn_uint32* count, + XrViewConfigurationType* types) { + (void)instance; + if (systemId != gn_system_id) return XR_ERROR_SYSTEM_INVALID; + XrResult r = gn_copy_props(1, capacity, count); + if (XR_FAILED(r) || capacity == 0) return r; + types[0] = XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO; + return XR_SUCCESS; +} + +static XrResult XRAPI_CALL gn_xrGetViewConfigurationProperties( + XrInstance instance, + XrSystemId systemId, + XrViewConfigurationType type, + XrViewConfigurationProperties* properties) { + (void)instance; + if (systemId != gn_system_id || type != XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO || !properties) { + return XR_ERROR_VALIDATION_FAILURE; + } + properties->viewConfigurationType = type; + properties->fovMutable = XR_FALSE; + return XR_SUCCESS; +} + +static XrResult XRAPI_CALL gn_xrEnumerateViewConfigurationViews( + XrInstance instance, + XrSystemId systemId, + XrViewConfigurationType type, + gn_uint32 capacity, + gn_uint32* count, + XrViewConfigurationView* views) { + (void)instance; + char response[128]; + if (systemId != gn_system_id || type != XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO) { + return XR_ERROR_VIEW_CONFIGURATION_TYPE_UNSUPPORTED; + } + if (gn_bridge_call("GET_VIEWS", response, sizeof(response))) { + long long w = gn_parse_i64(response, "width", 0); + long long h = gn_parse_i64(response, "height", 0); + if (w > 0 && h > 0) { + gn_view_width = (gn_uint32)w; + gn_view_height = (gn_uint32)h; + } + } + XrResult r = gn_copy_props(2, capacity, count); + if (XR_FAILED(r) || capacity == 0) return r; + for (gn_uint32 i = 0; i < 2; ++i) { + views[i].recommendedImageRectWidth = gn_view_width; + views[i].maxImageRectWidth = gn_view_width > 2048 ? gn_view_width : 2048; + views[i].recommendedImageRectHeight = gn_view_height; + views[i].maxImageRectHeight = gn_view_height > 2048 ? gn_view_height : 2048; + views[i].recommendedSwapchainSampleCount = 1; + views[i].maxSwapchainSampleCount = 1; + } + return XR_SUCCESS; +} + + + + + +static XrResult XRAPI_CALL gn_xrCreateSession(XrInstance instance, const XrSessionCreateInfo* createInfo, XrSession* session) { + (void)instance; + if (!createInfo || createInfo->systemId != gn_system_id || !session) return XR_ERROR_VALIDATION_FAILURE; + { + typedef struct GnNextHeader { + XrStructureType type; + const struct GnNextHeader* next; + } GnNextHeader; + const GnNextHeader* next = (const GnNextHeader*)createInfo->next; + int binding_found = 0; + while (next) { + if (next->type == XR_TYPE_GRAPHICS_BINDING_VULKAN_KHR) { + const XrGraphicsBindingVulkanKHR* binding = + (const XrGraphicsBindingVulkanKHR*)next; + gn_gfx_api = GN_GFX_VULKAN; + binding_found = 1; + if (!gn_set_vulkan_context(binding)) { + gn_log_line("xrCreateSession: Vulkan unix context failed"); + return XR_ERROR_GRAPHICS_DEVICE_INVALID; + } + break; + } + if (next->type == XR_TYPE_GRAPHICS_BINDING_D3D11_KHR) { + const XrGraphicsBindingD3D11KHR* binding = + (const XrGraphicsBindingD3D11KHR*)next; + gn_gfx_api = GN_GFX_D3D11; + binding_found = 1; + if (!gn_set_d3d11_context(binding->device)) { + gn_log_line("xrCreateSession: DXVK native interop failed"); + return XR_ERROR_GRAPHICS_DEVICE_INVALID; + } + break; + } + if (next->type == XR_TYPE_GRAPHICS_BINDING_D3D12_KHR) { + const XrGraphicsBindingD3D12KHR* binding = + (const XrGraphicsBindingD3D12KHR*)next; + gn_gfx_api = GN_GFX_D3D12; + binding_found = 1; + if (!gn_set_d3d12_context(binding->device, binding->queue)) { + gn_log_line("xrCreateSession: vkd3d native interop failed"); + return XR_ERROR_GRAPHICS_DEVICE_INVALID; + } + break; + } + next = next->next; + } + if (!binding_found) { + gn_log_line("xrCreateSession: no supported graphics binding"); + return XR_ERROR_GRAPHICS_DEVICE_INVALID; + } + } + *session = gn_session; + gn_clear_events(); + gn_stopping_pushed = 0; + gn_exit_requested = 0; + gn_action_sets_attached = 0; + gn_push_session_event(XR_SESSION_STATE_IDLE); + gn_push_session_event(XR_SESSION_STATE_READY); + gn_log_line("xrCreateSession"); + return XR_SUCCESS; +} + +static XrResult XRAPI_CALL gn_xrDestroySession(XrSession session) { + (void)session; + for (gn_uint32 i = 0; i < gn_swapchain_count; ++i) { + if (gn_swapchains[i].used && gn_unix_handle) { + for (gn_uint32 image = 0; image < gn_swapchains[i].image_count; ++image) { + if (gn_swapchains[i].d3d_images[image]) + gn_com_release(gn_swapchains[i].d3d_images[image]); + } + struct gn_unix_destroy_swapchain_args args; + args.slot = i; + args.result = GN_UNIX_ERROR_UNAVAILABLE; + gn_unix_call(GN_UNIX_DESTROY_SWAPCHAIN, &args); + } + gn_swapchains[i].used = 0; + } + gn_swapchain_count = 0; + gn_bridge_call("SWAPCHAIN_RESET", NULL, 0); + if (gn_dxvk_interop) { + gn_com_release(gn_dxvk_interop); + gn_dxvk_interop = NULL; + } + if (gn_vkd3d_device_ext) { + gn_com_release(gn_vkd3d_device_ext); + gn_vkd3d_device_ext = NULL; + } + if (gn_vkd3d_interop) { + gn_com_release(gn_vkd3d_interop); + gn_vkd3d_interop = NULL; + } + gn_d3d12_queue = NULL; + gn_session_running = 0; + gn_clear_events(); + gn_log_line("xrDestroySession"); + return XR_SUCCESS; +} + +static XrResult XRAPI_CALL gn_xrBeginSession(XrSession session, const XrSessionBeginInfo* beginInfo) { + (void)beginInfo; + if (session != gn_session) return XR_ERROR_HANDLE_INVALID; + gn_bridge_call("BEGIN_SESSION", NULL, 0); + gn_session_running = 1; + gn_stopping_pushed = 0; + gn_push_session_event(XR_SESSION_STATE_SYNCHRONIZED); + gn_push_session_event(XR_SESSION_STATE_VISIBLE); + gn_push_session_event(XR_SESSION_STATE_FOCUSED); + gn_log_line("xrBeginSession"); + return XR_SUCCESS; +} + +static XrResult XRAPI_CALL gn_xrEndSession(XrSession session) { + if (session != gn_session) return XR_ERROR_HANDLE_INVALID; + gn_bridge_call("END_SESSION", NULL, 0); + gn_session_running = 0; + gn_push_session_event(gn_exit_requested ? XR_SESSION_STATE_EXITING : XR_SESSION_STATE_IDLE); + gn_log_line("xrEndSession"); + return XR_SUCCESS; +} + +static XrResult XRAPI_CALL gn_xrRequestExitSession(XrSession session) { + if (session != gn_session) return XR_ERROR_HANDLE_INVALID; + gn_exit_requested = 1; + gn_bridge_call("REQUEST_EXIT", NULL, 0); + if (!gn_stopping_pushed) { + gn_stopping_pushed = 1; + gn_push_session_event(XR_SESSION_STATE_STOPPING); + } + gn_log_line("xrRequestExitSession -> STOPPING"); + return XR_SUCCESS; +} + + + + + +static XrResult XRAPI_CALL gn_xrEnumerateReferenceSpaces(XrSession session, gn_uint32 capacity, gn_uint32* count, XrReferenceSpaceType* spaces) { + if (session != gn_session) return XR_ERROR_HANDLE_INVALID; + { + char response[128]; + if (gn_bridge_call("GET_BOUNDS", response, sizeof(response))) + gn_stage_supported = gn_parse_i64(response, "supported", 1) != 0; + } + XrResult r = gn_copy_props(gn_stage_supported ? 3 : 2, capacity, count); + if (XR_FAILED(r) || capacity == 0) return r; + spaces[0] = XR_REFERENCE_SPACE_TYPE_VIEW; + if (capacity > 1) spaces[1] = XR_REFERENCE_SPACE_TYPE_LOCAL; + if (gn_stage_supported && capacity > 2) spaces[2] = XR_REFERENCE_SPACE_TYPE_STAGE; + return XR_SUCCESS; +} + +static XrResult XRAPI_CALL gn_xrCreateReferenceSpace(XrSession session, const XrReferenceSpaceCreateInfo* createInfo, XrSpace* space) { + if (session != gn_session) return XR_ERROR_HANDLE_INVALID; + if (!space || !createInfo || + createInfo->type != XR_TYPE_REFERENCE_SPACE_CREATE_INFO) + return XR_ERROR_VALIDATION_FAILURE; + if (createInfo->referenceSpaceType != XR_REFERENCE_SPACE_TYPE_VIEW && + createInfo->referenceSpaceType != XR_REFERENCE_SPACE_TYPE_LOCAL && + createInfo->referenceSpaceType != XR_REFERENCE_SPACE_TYPE_STAGE) + return XR_ERROR_REFERENCE_SPACE_UNSUPPORTED; + if (createInfo->referenceSpaceType == XR_REFERENCE_SPACE_TYPE_STAGE && !gn_stage_supported) + return XR_ERROR_REFERENCE_SPACE_UNSUPPORTED; + if (gn_ref_space_count >= GN_MAX_REF_SPACES) return XR_ERROR_LIMIT_REACHED; + gn_ref_spaces[gn_ref_space_count].used = 1; + gn_ref_spaces[gn_ref_space_count].type = createInfo->referenceSpaceType; + gn_ref_spaces[gn_ref_space_count].pose_in_reference_space = createInfo->poseInReferenceSpace; + *space = (XrSpace)(GN_REFSPACE_BASE | gn_ref_space_count); + ++gn_ref_space_count; + return XR_SUCCESS; +} + +static XrResult XRAPI_CALL gn_xrGetReferenceSpaceBoundsRect( + XrSession session, + XrReferenceSpaceType referenceSpaceType, + XrExtent2Df* bounds) { + if (session != gn_session) return XR_ERROR_HANDLE_INVALID; + if (!bounds) return XR_ERROR_VALIDATION_FAILURE; + bounds->width = 0.0f; + bounds->height = 0.0f; + if (referenceSpaceType != XR_REFERENCE_SPACE_TYPE_STAGE || !gn_stage_supported) + return XR_SPACE_BOUNDS_UNAVAILABLE; + { + char response[128]; + if (gn_bridge_call("GET_BOUNDS", response, sizeof(response)) && + gn_parse_i64(response, "available", 0) != 0) { + bounds->width = gn_parse_micro(response, "width", 0.0f); + bounds->height = gn_parse_micro(response, "height", 0.0f); + if (bounds->width > 0.0f && bounds->height > 0.0f) + return XR_SUCCESS; + } + } + return XR_SPACE_BOUNDS_UNAVAILABLE; +} + +static XrResult XRAPI_CALL gn_xrCreateActionSpace(XrSession session, const XrActionSpaceCreateInfo* createInfo, XrSpace* space) { + if (session != gn_session || !space || !createInfo) return XR_ERROR_HANDLE_INVALID; + int action_idx = gn_action_index(createInfo->action); + if (action_idx < 0) return XR_ERROR_HANDLE_INVALID; + if (gn_action_space_count >= GN_MAX_ACTION_SPACES) return XR_ERROR_LIMIT_REACHED; + gn_action_spaces[gn_action_space_count].used = 1; + gn_action_spaces[gn_action_space_count].action_idx = action_idx; + gn_action_spaces[gn_action_space_count].hand = gn_hand_from_path(createInfo->subactionPath); + gn_action_spaces[gn_action_space_count].pose_in_action_space = createInfo->poseInActionSpace; + *space = (XrSpace)(GN_ACTSPACE_BASE | gn_action_space_count); + ++gn_action_space_count; + return XR_SUCCESS; +} + +static XrResult XRAPI_CALL gn_xrDestroySpace(XrSpace space) { + int idx = gn_ref_space_index(space); + if (idx >= 0) { + gn_ref_spaces[idx].used = 0; + return XR_SUCCESS; + } + idx = gn_action_space_index(space); + if (idx >= 0) { + gn_action_spaces[idx].used = 0; + return XR_SUCCESS; + } + return XR_ERROR_HANDLE_INVALID; +} + +static void gn_identity_pose(XrPosef* pose) { + pose->orientation.x = 0.0f; + pose->orientation.y = 0.0f; + pose->orientation.z = 0.0f; + pose->orientation.w = 1.0f; + pose->position.x = 0.0f; + pose->position.y = 0.0f; + pose->position.z = 0.0f; +} + +static XrQuaternionf gn_quat_multiply(XrQuaternionf a, XrQuaternionf b) { + XrQuaternionf q; + q.x = a.w * b.x + a.x * b.w + a.y * b.z - a.z * b.y; + q.y = a.w * b.y - a.x * b.z + a.y * b.w + a.z * b.x; + q.z = a.w * b.z + a.x * b.y - a.y * b.x + a.z * b.w; + q.w = a.w * b.w - a.x * b.x - a.y * b.y - a.z * b.z; + return q; +} + +static XrVector3f gn_quat_rotate(XrQuaternionf q, XrVector3f v) { + XrVector3f out; + + float tx = 2.0f * (q.y * v.z - q.z * v.y); + float ty = 2.0f * (q.z * v.x - q.x * v.z); + float tz = 2.0f * (q.x * v.y - q.y * v.x); + out.x = v.x + q.w * tx + (q.y * tz - q.z * ty); + out.y = v.y + q.w * ty + (q.z * tx - q.x * tz); + out.z = v.z + q.w * tz + (q.x * ty - q.y * tx); + return out; +} + +static XrPosef gn_pose_multiply(XrPosef a, XrPosef b) { + XrPosef out; + XrVector3f rotated = gn_quat_rotate(a.orientation, b.position); + out.orientation = gn_quat_multiply(a.orientation, b.orientation); + out.position.x = a.position.x + rotated.x; + out.position.y = a.position.y + rotated.y; + out.position.z = a.position.z + rotated.z; + return out; +} + +static XrPosef gn_pose_inverse(XrPosef pose) { + XrPosef out; + XrVector3f negative; + out.orientation.x = -pose.orientation.x; + out.orientation.y = -pose.orientation.y; + out.orientation.z = -pose.orientation.z; + out.orientation.w = pose.orientation.w; + negative.x = -pose.position.x; + negative.y = -pose.position.y; + negative.z = -pose.position.z; + out.position = gn_quat_rotate(out.orientation, negative); + return out; +} + +static void gn_get_head_pose(XrPosef* pose) { + gn_identity_pose(pose); + if (!gn_eye_views_valid) return; + pose->orientation.x = gn_eye_views[0].quat[0]; + pose->orientation.y = gn_eye_views[0].quat[1]; + pose->orientation.z = gn_eye_views[0].quat[2]; + pose->orientation.w = gn_eye_views[0].quat[3]; + pose->position.x = (gn_eye_views[0].pos[0] + gn_eye_views[1].pos[0]) * 0.5f; + pose->position.y = (gn_eye_views[0].pos[1] + gn_eye_views[1].pos[1]) * 0.5f; + pose->position.z = (gn_eye_views[0].pos[2] + gn_eye_views[1].pos[2]) * 0.5f; +} + + +static int gn_space_absolute_pose( + XrSpace space, + XrPosef* pose, + float linear_velocity[3], + float angular_velocity[3]) { + int ref_idx = gn_ref_space_index(space); + gn_identity_pose(pose); + for (int i = 0; i < 3; ++i) { + linear_velocity[i] = 0.0f; + angular_velocity[i] = 0.0f; + } + if (ref_idx >= 0) { + XrPosef natural; + gn_identity_pose(&natural); + if (gn_ref_spaces[ref_idx].type == XR_REFERENCE_SPACE_TYPE_VIEW) { + if (!gn_eye_views_valid) return 0; + gn_get_head_pose(&natural); + for (int i = 0; i < 3; ++i) { + linear_velocity[i] = gn_head_linear_velocity[i]; + angular_velocity[i] = gn_head_angular_velocity[i]; + } + } else if (gn_ref_spaces[ref_idx].type == XR_REFERENCE_SPACE_TYPE_LOCAL) { + if (gn_local_origin_valid) natural = gn_local_origin; + } else if (gn_ref_spaces[ref_idx].type != XR_REFERENCE_SPACE_TYPE_STAGE) { + return -1; + } + *pose = gn_pose_multiply(natural, gn_ref_spaces[ref_idx].pose_in_reference_space); + return 1; + } + + int action_space_idx = gn_action_space_index(space); + if (action_space_idx >= 0) { + const GnActionSpace* action_space = &gn_action_spaces[action_space_idx]; + const GnAction* action = &gn_actions[action_space->action_idx]; + int hand = action_space->hand >= 0 ? action_space->hand : gn_action_default_hand(action); + int comp = action->component[hand]; + XrPosef tracked; + if (!gn_hands[hand].active || (action->active_hands & (1u << hand)) == 0) return 0; + gn_write_pose(&tracked, comp == GN_COMP_AIM_POSE ? gn_hands[hand].aim : gn_hands[hand].grip); + *pose = gn_pose_multiply(tracked, action_space->pose_in_action_space); + for (int i = 0; i < 3; ++i) { + linear_velocity[i] = gn_hand_linear_velocity[hand][i]; + angular_velocity[i] = gn_hand_angular_velocity[hand][i]; + } + return 1; + } + return -1; +} + +static XrResult XRAPI_CALL gn_xrLocateSpace(XrSpace space, XrSpace baseSpace, XrTime time, XrSpaceLocation* location) { + (void)time; + XrPosef absolute_pose, base_pose; + float linear[3], angular[3], base_linear[3], base_angular[3]; + if (!location) return XR_ERROR_VALIDATION_FAILURE; + + int space_status = gn_space_absolute_pose(space, &absolute_pose, linear, angular); + int base_status = gn_space_absolute_pose(baseSpace, &base_pose, base_linear, base_angular); + if (space_status < 0 || base_status < 0) return XR_ERROR_HANDLE_INVALID; + + if (location->next) { + XrSpaceVelocity* velocity = (XrSpaceVelocity*)location->next; + if (velocity->type == XR_TYPE_SPACE_VELOCITY) { + velocity->velocityFlags = 0; + velocity->linearVelocity.x = 0.0f; + velocity->linearVelocity.y = 0.0f; + velocity->linearVelocity.z = 0.0f; + velocity->angularVelocity.x = 0.0f; + velocity->angularVelocity.y = 0.0f; + velocity->angularVelocity.z = 0.0f; + if (space_status > 0 && base_status > 0) { + XrQuaternionf base_inverse = gn_pose_inverse(base_pose).orientation; + XrVector3f relative_linear = { + linear[0] - base_linear[0], + linear[1] - base_linear[1], + linear[2] - base_linear[2], + }; + XrVector3f relative_angular = { + angular[0] - base_angular[0], + angular[1] - base_angular[1], + angular[2] - base_angular[2], + }; + velocity->linearVelocity = gn_quat_rotate(base_inverse, relative_linear); + velocity->angularVelocity = gn_quat_rotate(base_inverse, relative_angular); + velocity->velocityFlags = + XR_SPACE_VELOCITY_LINEAR_VALID_BIT | XR_SPACE_VELOCITY_ANGULAR_VALID_BIT; + } + } + } + + location->locationFlags = 0; + gn_identity_pose(&location->pose); + if (space_status == 0 || base_status == 0) return XR_SUCCESS; + location->pose = gn_pose_multiply(gn_pose_inverse(base_pose), absolute_pose); + location->locationFlags = + XR_SPACE_LOCATION_ORIENTATION_VALID_BIT | + XR_SPACE_LOCATION_POSITION_VALID_BIT | + XR_SPACE_LOCATION_ORIENTATION_TRACKED_BIT | + XR_SPACE_LOCATION_POSITION_TRACKED_BIT; + return XR_SUCCESS; +} + +static XrResult XRAPI_CALL gn_xrLocateSpaces( + XrSession session, + const XrSpacesLocateInfo* locateInfo, + XrSpaceLocations* spaceLocations) { + if (session != gn_session) return XR_ERROR_HANDLE_INVALID; + if (!locateInfo || locateInfo->type != XR_TYPE_SPACES_LOCATE_INFO || + !spaceLocations || spaceLocations->type != XR_TYPE_SPACE_LOCATIONS || + locateInfo->spaceCount != spaceLocations->locationCount || + (locateInfo->spaceCount && (!locateInfo->spaces || !spaceLocations->locations))) { + return XR_ERROR_VALIDATION_FAILURE; + } + + XrSpaceVelocities* space_velocities = NULL; + if (spaceLocations->next) { + typedef struct GnOutHeader { + XrStructureType type; + void* next; + } GnOutHeader; + GnOutHeader* next = (GnOutHeader*)spaceLocations->next; + while (next) { + if (next->type == XR_TYPE_SPACE_VELOCITIES) { + space_velocities = (XrSpaceVelocities*)next; + break; + } + next = (GnOutHeader*)next->next; + } + } + if (space_velocities && + (space_velocities->velocityCount != locateInfo->spaceCount || + (space_velocities->velocityCount && !space_velocities->velocities))) { + return XR_ERROR_VALIDATION_FAILURE; + } + + for (uint32_t i = 0; i < locateInfo->spaceCount; ++i) { + XrSpaceVelocity velocity = { + XR_TYPE_SPACE_VELOCITY, + NULL, + 0, + {0.0f, 0.0f, 0.0f}, + {0.0f, 0.0f, 0.0f}, + }; + XrSpaceLocation location = { + XR_TYPE_SPACE_LOCATION, + space_velocities ? &velocity : NULL, + 0, + {{0.0f, 0.0f, 0.0f, 1.0f}, {0.0f, 0.0f, 0.0f}}, + }; + XrResult result = gn_xrLocateSpace( + locateInfo->spaces[i], + locateInfo->baseSpace, + locateInfo->time, + &location); + if (XR_FAILED(result)) return result; + + spaceLocations->locations[i].locationFlags = location.locationFlags; + spaceLocations->locations[i].pose = location.pose; + if (space_velocities) { + space_velocities->velocities[i].velocityFlags = velocity.velocityFlags; + space_velocities->velocities[i].linearVelocity = velocity.linearVelocity; + space_velocities->velocities[i].angularVelocity = velocity.angularVelocity; + } + } + return XR_SUCCESS; +} + + + + + +static XrResult XRAPI_CALL gn_xrWaitFrame(XrSession session, const XrFrameWaitInfo* waitInfo, XrFrameState* frameState) { + (void)waitInfo; + char response[160]; + if (session != gn_session || !frameState) return XR_ERROR_HANDLE_INVALID; + if (gn_bridge_call("WAIT_FRAME", response, sizeof(response))) { + frameState->predictedDisplayTime = gn_parse_i64(response, "time", gn_next_display_time); + frameState->predictedDisplayPeriod = gn_parse_i64(response, "period", 11111111); + frameState->shouldRender = gn_parse_i64(response, "render", gn_session_running ? 1 : 0) != 0 ? XR_TRUE : XR_FALSE; + gn_next_display_time = frameState->predictedDisplayTime + frameState->predictedDisplayPeriod; + + long long quest_state = gn_parse_i64(response, "state", 0); + if (quest_state == XR_SESSION_STATE_LOSS_PENDING) { + gn_instance_loss_event_pending = 1; + } + if (quest_state >= XR_SESSION_STATE_STOPPING && gn_session_running && !gn_stopping_pushed) { + gn_stopping_pushed = 1; + gn_push_session_event(XR_SESSION_STATE_STOPPING); + gn_log_num("quest session stopping, state=", quest_state); + } + } else { + frameState->predictedDisplayTime = gn_next_display_time; + frameState->predictedDisplayPeriod = 11111111; + frameState->shouldRender = gn_session_running ? XR_TRUE : XR_FALSE; + gn_next_display_time += frameState->predictedDisplayPeriod; + } + return XR_SUCCESS; +} + +static XrResult XRAPI_CALL gn_xrBeginFrame(XrSession session, const XrFrameBeginInfo* frameBeginInfo) { + if (session != gn_session) return XR_ERROR_HANDLE_INVALID; + if (!frameBeginInfo || frameBeginInfo->type != XR_TYPE_FRAME_BEGIN_INFO) + return XR_ERROR_VALIDATION_FAILURE; + + + return XR_SUCCESS; +} + +static XrResult XRAPI_CALL gn_xrEndFrame(XrSession session, const XrFrameEndInfo* frameEndInfo) { + if (session != gn_session) return XR_ERROR_HANDLE_INVALID; + if (!frameEndInfo || frameEndInfo->type != XR_TYPE_FRAME_END_INFO || + (frameEndInfo->layerCount && !frameEndInfo->layers)) + return XR_ERROR_VALIDATION_FAILURE; + + for (gn_uint32 layer_index = 0; layer_index < frameEndInfo->layerCount; ++layer_index) { + const XrCompositionLayerBaseHeader* base = frameEndInfo->layers[layer_index]; + if (!base) return XR_ERROR_LAYER_INVALID; + if (base->type == XR_TYPE_COMPOSITION_LAYER_PROJECTION) { + const XrCompositionLayerProjection* projection = + (const XrCompositionLayerProjection*)base; + if (projection->viewCount != 2 || !projection->views) + return XR_ERROR_VALIDATION_FAILURE; + for (gn_uint32 eye = 0; eye < projection->viewCount; ++eye) { + if (projection->views[eye].type != + XR_TYPE_COMPOSITION_LAYER_PROJECTION_VIEW) + return XR_ERROR_VALIDATION_FAILURE; + const XrSwapchainSubImage* sub_image = + &projection->views[eye].subImage; + int slot = gn_swapchain_index(sub_image->swapchain); + if (slot < 0) return XR_ERROR_LAYER_INVALID; + const GnSwapchain* state = &gn_swapchains[slot]; + if (sub_image->imageArrayIndex >= state->create_info.arraySize || + sub_image->imageRect.offset.x < 0 || + sub_image->imageRect.offset.y < 0 || + sub_image->imageRect.extent.width <= 0 || + sub_image->imageRect.extent.height <= 0 || + sub_image->imageRect.extent.width > + (int32_t)state->create_info.width - + sub_image->imageRect.offset.x || + sub_image->imageRect.extent.height > + (int32_t)state->create_info.height - + sub_image->imageRect.offset.y) + return XR_ERROR_SWAPCHAIN_RECT_INVALID; + } + } + } + + int submission_failed = 0; + if (gn_gfx_api == GN_GFX_D3D11) gn_dxvk_flush_and_lock(); + if (gn_gfx_api == GN_GFX_D3D12) gn_vkd3d_lock(); + for (gn_uint32 layer_index = 0; + layer_index < frameEndInfo->layerCount; ++layer_index) { + const XrCompositionLayerBaseHeader* base = + frameEndInfo->layers[layer_index]; + if (base->type != XR_TYPE_COMPOSITION_LAYER_PROJECTION) continue; + const XrCompositionLayerProjection* projection = + (const XrCompositionLayerProjection*)base; + XrPosef layer_space_pose; + float layer_linear[3], layer_angular[3]; + int layer_space_status = gn_space_absolute_pose( + projection->space, &layer_space_pose, + layer_linear, layer_angular); + if (layer_space_status <= 0) { + submission_failed = 1; + continue; + } + struct gn_unix_submit_stereo_args args; + args.view_count = projection->viewCount; + int projection_ready = 1; + for (gn_uint32 eye = 0; eye < projection->viewCount; ++eye) { + int slot = gn_swapchain_index( + projection->views[eye].subImage.swapchain); + GnSwapchain* state = &gn_swapchains[slot]; + if (!state->last_released_valid) { + submission_failed = 1; + projection_ready = 0; + break; + } + struct gn_unix_submit_view_args* view = &args.views[eye]; + view->slot = (gn_u32)slot; + view->image_index = state->last_released_image; + view->eye = eye; + view->array_index = + projection->views[eye].subImage.imageArrayIndex; + view->rect_x = + projection->views[eye].subImage.imageRect.offset.x; + view->rect_y = + projection->views[eye].subImage.imageRect.offset.y; + view->rect_width = (gn_u32) + projection->views[eye].subImage.imageRect.extent.width; + view->rect_height = (gn_u32) + projection->views[eye].subImage.imageRect.extent.height; + { + XrPosef absolute_view = gn_pose_multiply( + layer_space_pose, projection->views[eye].pose); + view->orientation_micro[0] = + gn_float_to_micro(absolute_view.orientation.x); + view->orientation_micro[1] = + gn_float_to_micro(absolute_view.orientation.y); + view->orientation_micro[2] = + gn_float_to_micro(absolute_view.orientation.z); + view->orientation_micro[3] = + gn_float_to_micro(absolute_view.orientation.w); + view->position_micro[0] = + gn_float_to_micro(absolute_view.position.x); + view->position_micro[1] = + gn_float_to_micro(absolute_view.position.y); + view->position_micro[2] = + gn_float_to_micro(absolute_view.position.z); + view->fov_micro[0] = gn_float_to_micro( + projection->views[eye].fov.angleLeft); + view->fov_micro[1] = gn_float_to_micro( + projection->views[eye].fov.angleRight); + view->fov_micro[2] = gn_float_to_micro( + projection->views[eye].fov.angleUp); + view->fov_micro[3] = gn_float_to_micro( + projection->views[eye].fov.angleDown); + } + } + if (!projection_ready) continue; + args.result = GN_UNIX_ERROR_UNAVAILABLE; + if (!gn_unix_call(GN_UNIX_SUBMIT_STEREO, &args) || + args.result != GN_UNIX_SUCCESS) { + submission_failed = 1; + if (!gn_transport_failure_logged) { + gn_log_num("xrEndFrame stereo transport failed result=", args.result); + gn_transport_failure_logged = 1; + } + } else { + for (gn_uint32 eye = 0; eye < projection->viewCount; ++eye) { + int slot = (int)args.views[eye].slot; + GnSwapchain* state = &gn_swapchains[slot]; + state->submitted[state->last_released_image] = 1; + gn_transport_eye_mask |= (1u << eye); + } + if (gn_transport_eye_mask == 3u) { + gn_log_line("xrEndFrame batched image transport accepted both eyes"); + gn_transport_eye_mask |= 4u; + } + } + } + for (gn_uint32 i = 0; i < gn_swapchain_count; ++i) + gn_swapchains[i].last_released_valid = 0; + if (gn_gfx_api == GN_GFX_D3D11) gn_dxvk_unlock(); + if (gn_gfx_api == GN_GFX_D3D12) gn_vkd3d_unlock(); + + + + if (!gn_frame_milestone_sent && frameEndInfo->layerCount > 0) { + char cmd[64]; + gn_size n = gn_append(cmd, sizeof(cmd), 0, "END_FRAME layers="); + n = gn_append_i64(cmd, sizeof(cmd), n, (long long)frameEndInfo->layerCount); + if (gn_bridge_call(cmd, NULL, 0)) gn_frame_milestone_sent = 1; + } + return submission_failed ? XR_ERROR_RUNTIME_FAILURE : XR_SUCCESS; +} + +static XrResult XRAPI_CALL gn_xrLocateViews( + XrSession session, + const XrViewLocateInfo* viewLocateInfo, + XrViewState* viewState, + gn_uint32 capacity, + gn_uint32* count, + XrView* views) { + char response[512]; + if (session != gn_session) return XR_ERROR_HANDLE_INVALID; + if (!viewLocateInfo || viewLocateInfo->type != XR_TYPE_VIEW_LOCATE_INFO || + !viewState || viewState->type != XR_TYPE_VIEW_STATE || !count || + (capacity && !views)) { + return XR_ERROR_VALIDATION_FAILURE; + } + if (viewLocateInfo->viewConfigurationType != + XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO) { + return XR_ERROR_VIEW_CONFIGURATION_TYPE_UNSUPPORTED; + } + + XrResult r = gn_copy_props(2, capacity, count); + if (XR_FAILED(r) || capacity == 0) return r; + for (gn_uint32 i = 0; i < 2; ++i) { + if (views[i].type != XR_TYPE_VIEW) + return XR_ERROR_VALIDATION_FAILURE; + } + + if (gn_bridge_call("LOCATE_VIEWS", response, sizeof(response))) { + static const char* qk[2][4] = {{"lqx", "lqy", "lqz", "lqw"}, {"rqx", "rqy", "rqz", "rqw"}}; + static const char* pk[2][3] = {{"lpx", "lpy", "lpz"}, {"rpx", "rpy", "rpz"}}; + static const char* fk[2][4] = {{"lfl", "lfr", "lfu", "lfd"}, {"rfl", "rfr", "rfu", "rfd"}}; + for (int eye = 0; eye < 2; ++eye) { + GnEyeView* v = &gn_eye_views[eye]; + for (int i = 0; i < 4; ++i) v->quat[i] = gn_parse_micro(response, qk[eye][i], i == 3 ? 1.0f : 0.0f); + for (int i = 0; i < 3; ++i) v->pos[i] = gn_parse_micro(response, pk[eye][i], 0.0f); + v->fov[0] = gn_parse_micro(response, fk[eye][0], -0.75f); + v->fov[1] = gn_parse_micro(response, fk[eye][1], 0.75f); + v->fov[2] = gn_parse_micro(response, fk[eye][2], 0.75f); + v->fov[3] = gn_parse_micro(response, fk[eye][3], -0.75f); + } + gn_eye_views_valid = 1; + { + XrPosef head_pose; + gn_get_head_pose(&head_pose); + if (!gn_local_origin_valid) { + gn_local_origin = head_pose; + gn_local_origin_valid = 1; + } + gn_update_pose_velocity( + &head_pose, + viewLocateInfo ? viewLocateInfo->displayTime : gn_next_display_time, + &gn_last_head_pose, + &gn_last_head_time, + gn_head_linear_velocity, + gn_head_angular_velocity, + 1); + } + } + + XrPosef base_pose; + float base_linear[3], base_angular[3]; + int base_status = gn_space_absolute_pose( + viewLocateInfo->space, &base_pose, base_linear, base_angular); + if (base_status < 0) return XR_ERROR_HANDLE_INVALID; + XrPosef base_inverse = gn_pose_inverse(base_pose); + + viewState->viewStateFlags = 0; + if (gn_eye_views_valid && base_status > 0) { + viewState->viewStateFlags = + XR_VIEW_STATE_ORIENTATION_VALID_BIT | XR_VIEW_STATE_POSITION_VALID_BIT | + XR_VIEW_STATE_ORIENTATION_TRACKED_BIT | XR_VIEW_STATE_POSITION_TRACKED_BIT; + } + for (gn_uint32 i = 0; i < 2; ++i) { + if (gn_eye_views_valid) { + const GnEyeView* v = &gn_eye_views[i]; + XrPosef absolute_eye; + absolute_eye.orientation.x = v->quat[0]; + absolute_eye.orientation.y = v->quat[1]; + absolute_eye.orientation.z = v->quat[2]; + absolute_eye.orientation.w = v->quat[3]; + absolute_eye.position.x = v->pos[0]; + absolute_eye.position.y = v->pos[1]; + absolute_eye.position.z = v->pos[2]; + views[i].pose = base_status > 0 + ? gn_pose_multiply(base_inverse, absolute_eye) + : absolute_eye; + views[i].fov.angleLeft = v->fov[0]; + views[i].fov.angleRight = v->fov[1]; + views[i].fov.angleUp = v->fov[2]; + views[i].fov.angleDown = v->fov[3]; + } else { + gn_identity_pose(&views[i].pose); + views[i].pose.position.x = i == 0 ? -0.032f : 0.032f; + views[i].fov.angleLeft = -0.75f; + views[i].fov.angleRight = 0.75f; + views[i].fov.angleUp = 0.75f; + views[i].fov.angleDown = -0.75f; + } + } + return XR_SUCCESS; +} + + + + + +static XrResult XRAPI_CALL gn_xrEnumerateSwapchainFormats(XrSession session, gn_uint32 capacity, gn_uint32* count, int64_t* formats) { + if (session != gn_session) return XR_ERROR_HANDLE_INVALID; + + + + + static const int64_t vk_formats[] = {50 , 44 , 43 , 37 }; + static const int64_t d3d_formats[] = {91 , 87 , 29 , 28 }; + const int64_t* list = + (gn_gfx_api == GN_GFX_D3D11 || gn_gfx_api == GN_GFX_D3D12) ? + d3d_formats : vk_formats; + XrResult r = gn_copy_props(4, capacity, count); + if (XR_FAILED(r) || capacity == 0) return r; + for (gn_uint32 i = 0; i < 4 && i < capacity; ++i) formats[i] = list[i]; + return XR_SUCCESS; +} + +static XrResult XRAPI_CALL gn_xrGetD3D11GraphicsRequirementsKHR( + XrInstance instance, + XrSystemId systemId, + XrGraphicsRequirementsD3D11KHR* graphicsRequirements) { + (void)instance; + if (systemId != gn_system_id || !graphicsRequirements) return XR_ERROR_VALIDATION_FAILURE; + gn_gfx_api = GN_GFX_D3D11; + gn_log_line("graphics binding requested: d3d11"); + gn_bridge_call("GFX_API d3d11", NULL, 0); + graphicsRequirements->adapterLuid = gn_primary_adapter_luid(); + graphicsRequirements->minFeatureLevel = D3D_FEATURE_LEVEL_11_0; + return XR_SUCCESS; +} + +static XrResult XRAPI_CALL gn_xrGetD3D12GraphicsRequirementsKHR( + XrInstance instance, + XrSystemId systemId, + XrGraphicsRequirementsD3D12KHR* graphicsRequirements) { + (void)instance; + if (systemId != gn_system_id || !graphicsRequirements) return XR_ERROR_VALIDATION_FAILURE; + gn_gfx_api = GN_GFX_D3D12; + gn_log_line("graphics binding requested: d3d12"); + gn_bridge_call("GFX_API d3d12", NULL, 0); + graphicsRequirements->adapterLuid = gn_primary_adapter_luid(); + graphicsRequirements->minFeatureLevel = D3D_FEATURE_LEVEL_11_0; + return XR_SUCCESS; +} + +static XrResult XRAPI_CALL gn_xrGetVulkanInstanceExtensionsKHR( + XrInstance instance, + XrSystemId systemId, + gn_uint32 bufferCapacityInput, + gn_uint32* bufferCountOutput, + char* buffer) { + (void)instance; + if (systemId != gn_system_id) return XR_ERROR_SYSTEM_INVALID; + return gn_fill_string(GN_VULKAN_INSTANCE_EXTENSIONS, bufferCapacityInput, bufferCountOutput, buffer); +} + +static XrResult XRAPI_CALL gn_xrGetVulkanDeviceExtensionsKHR( + XrInstance instance, + XrSystemId systemId, + gn_uint32 bufferCapacityInput, + gn_uint32* bufferCountOutput, + char* buffer) { + (void)instance; + if (systemId != gn_system_id) return XR_ERROR_SYSTEM_INVALID; + return gn_fill_string(GN_VULKAN_DEVICE_EXTENSIONS, bufferCapacityInput, bufferCountOutput, buffer); +} + +static XrResult XRAPI_CALL gn_xrGetVulkanGraphicsDeviceKHR( + XrInstance instance, + XrSystemId systemId, + VkInstance vkInstance, + VkPhysicalDevice* vkPhysicalDevice) { + (void)instance; + if (systemId != gn_system_id || !vkPhysicalDevice) return XR_ERROR_VALIDATION_FAILURE; + *vkPhysicalDevice = gn_first_vulkan_physical_device(vkInstance); + if (!*vkPhysicalDevice) return XR_ERROR_GRAPHICS_DEVICE_INVALID; + gn_vk_instance = vkInstance; + gn_vk_physical_device = *vkPhysicalDevice; + return XR_SUCCESS; +} + +static XrResult XRAPI_CALL gn_xrGetVulkanGraphicsRequirementsKHR( + XrInstance instance, + XrSystemId systemId, + XrGraphicsRequirementsVulkanKHR* graphicsRequirements) { + (void)instance; + if (systemId != gn_system_id || !graphicsRequirements) return XR_ERROR_VALIDATION_FAILURE; + gn_gfx_api = GN_GFX_VULKAN; + gn_log_line("graphics binding requested: vulkan"); + gn_bridge_call("GFX_API vulkan", NULL, 0); + graphicsRequirements->minApiVersionSupported = XR_MAKE_VERSION(1, 1, 0); + graphicsRequirements->maxApiVersionSupported = XR_MAKE_VERSION(1, 3, 0); + return XR_SUCCESS; +} + +static XrResult XRAPI_CALL gn_xrGetVulkanGraphicsDevice2KHR( + XrInstance instance, + const XrVulkanGraphicsDeviceGetInfoKHR* getInfo, + VkPhysicalDevice* vulkanPhysicalDevice) { + (void)instance; + if (!getInfo || !vulkanPhysicalDevice) return XR_ERROR_VALIDATION_FAILURE; + if (getInfo->systemId != gn_system_id) return XR_ERROR_SYSTEM_INVALID; + *vulkanPhysicalDevice = gn_first_vulkan_physical_device(getInfo->vulkanInstance); + if (!*vulkanPhysicalDevice) return XR_ERROR_GRAPHICS_DEVICE_INVALID; + gn_vk_instance = getInfo->vulkanInstance; + gn_vk_physical_device = *vulkanPhysicalDevice; + return XR_SUCCESS; +} + +static XrResult XRAPI_CALL gn_xrGetVulkanGraphicsRequirements2KHR( + XrInstance instance, + XrSystemId systemId, + XrGraphicsRequirementsVulkanKHR* graphicsRequirements) { + return gn_xrGetVulkanGraphicsRequirementsKHR(instance, systemId, graphicsRequirements); +} + +typedef VkResult (GN_STDCALL *GnVkCreateInstance)( + const void* createInfo, const void* allocator, VkInstance* instance); +typedef VkResult (GN_STDCALL *GnVkCreateDevice)( + VkPhysicalDevice physicalDevice, const void* createInfo, + const void* allocator, VkDevice* device); + +static XrResult XRAPI_CALL gn_xrCreateVulkanInstanceKHR( + XrInstance instance, + const XrVulkanInstanceCreateInfoKHR* createInfo, + VkInstance* vulkanInstance, + VkResult* vulkanResult) { + (void)instance; + if (!createInfo || createInfo->systemId != gn_system_id || + !createInfo->pfnGetInstanceProcAddr || !createInfo->vulkanCreateInfo || + !vulkanInstance || !vulkanResult) return XR_ERROR_VALIDATION_FAILURE; + GnVkCreateInstance create = + (GnVkCreateInstance)createInfo->pfnGetInstanceProcAddr(NULL, "vkCreateInstance"); + if (!create) return XR_ERROR_FUNCTION_UNSUPPORTED; + *vulkanResult = create( + createInfo->vulkanCreateInfo, createInfo->vulkanAllocator, vulkanInstance); + if (*vulkanResult == 0) gn_vk_instance = *vulkanInstance; + return XR_SUCCESS; +} + +static XrResult XRAPI_CALL gn_xrCreateVulkanDeviceKHR( + XrInstance instance, + const XrVulkanDeviceCreateInfoKHR* createInfo, + VkDevice* vulkanDevice, + VkResult* vulkanResult) { + (void)instance; + if (!createInfo || createInfo->systemId != gn_system_id || + !createInfo->pfnGetInstanceProcAddr || !createInfo->vulkanCreateInfo || + !createInfo->vulkanPhysicalDevice || !vulkanDevice || !vulkanResult) { + return XR_ERROR_VALIDATION_FAILURE; + } + GnVkCreateDevice create = + (GnVkCreateDevice)createInfo->pfnGetInstanceProcAddr( + gn_vk_instance, "vkCreateDevice"); + if (!create) return XR_ERROR_FUNCTION_UNSUPPORTED; + + *vulkanResult = create( + createInfo->vulkanPhysicalDevice, createInfo->vulkanCreateInfo, + createInfo->vulkanAllocator, vulkanDevice); + return XR_SUCCESS; +} + + + + + +static XrResult XRAPI_CALL gn_xrCreateSwapchain(XrSession session, const XrSwapchainCreateInfo* createInfo, XrSwapchain* swapchain) { + if (session != gn_session) return XR_ERROR_HANDLE_INVALID; + if (!createInfo || !swapchain || !createInfo->width || !createInfo->height || + !createInfo->arraySize || createInfo->faceCount != 1 || + createInfo->width > 16384 || createInfo->height > 16384 || + createInfo->arraySize > 65535 || createInfo->mipCount > 65535) { + return XR_ERROR_VALIDATION_FAILURE; + } + if (gn_gfx_api != GN_GFX_VULKAN && + gn_gfx_api != GN_GFX_D3D11 && + gn_gfx_api != GN_GFX_D3D12) { + gn_log_line("xrCreateSwapchain: graphics native interop is unavailable"); + return XR_ERROR_FEATURE_UNSUPPORTED; + } + + gn_uint32 slot = GN_MAX_SWAPCHAINS; + for (gn_uint32 i = 0; i < gn_swapchain_count; ++i) { + if (!gn_swapchains[i].used) { slot = i; break; } + } + if (slot == GN_MAX_SWAPCHAINS) { + if (gn_swapchain_count >= GN_MAX_SWAPCHAINS) return XR_ERROR_LIMIT_REACHED; + slot = gn_swapchain_count++; + } + + struct gn_unix_create_swapchain_args args; + gn_zero_memory(&args, sizeof(args)); + args.slot = slot; + args.width = createInfo->width; + args.height = createInfo->height; + args.array_size = createInfo->arraySize; + args.mip_count = createInfo->mipCount; + args.sample_count = createInfo->sampleCount; + args.format = (gn_gfx_api == GN_GFX_D3D11 || gn_gfx_api == GN_GFX_D3D12) ? + gn_d3d_format_to_vk(createInfo->format) : createInfo->format; + if (!args.format) return XR_ERROR_SWAPCHAIN_FORMAT_UNSUPPORTED; + gn_log_num("xrCreateSwapchain client format=", createInfo->format); + gn_log_num("xrCreateSwapchain Vulkan format=", args.format); + args.usage = createInfo->usageFlags; + args.result = GN_UNIX_ERROR_UNAVAILABLE; + if (!gn_unix_call(GN_UNIX_CREATE_SWAPCHAIN, &args) || + args.result != GN_UNIX_SUCCESS || args.image_count < 2 || + args.image_count > GN_UNIX_MAX_IMAGES) { + gn_log_num("xrCreateSwapchain unix result=", args.result); + return XR_ERROR_RUNTIME_FAILURE; + } + + GnSwapchain* state = &gn_swapchains[slot]; + gn_zero_memory(state, sizeof(*state)); + state->used = 1; + state->image_count = args.image_count; + state->create_info = *createInfo; + for (gn_uint32 i = 0; i < args.image_count; ++i) { + state->images[i] = args.images[i]; + state->image_state[i] = GN_IMAGE_AVAILABLE; + } + if (gn_gfx_api == GN_GFX_D3D11) { + GnDxvkCreateTexture create_texture = + (GnDxvkCreateTexture)gn_com_method(gn_dxvk_interop, 10); + GnD3D11Texture2DDesc1 desc; + gn_zero_memory(&desc, sizeof(desc)); + desc.Width = createInfo->width; + desc.Height = createInfo->height; + desc.MipLevels = createInfo->mipCount; + desc.ArraySize = createInfo->arraySize; + desc.Format = (int)createInfo->format; + desc.SampleDesc.Count = createInfo->sampleCount; + desc.Usage = 0; + desc.BindFlags = 0x8; + if (createInfo->usageFlags & XR_SWAPCHAIN_USAGE_COLOR_ATTACHMENT_BIT) + desc.BindFlags |= 0x20; + if (createInfo->usageFlags & XR_SWAPCHAIN_USAGE_UNORDERED_ACCESS_BIT) + desc.BindFlags |= 0x80; + for (gn_uint32 i = 0; i < args.image_count; ++i) { + ID3D11Texture2D* texture = NULL; + if (!create_texture || + create_texture(gn_dxvk_interop, &desc, + (VkImage)state->images[i], &texture) < 0 || + !texture) { + for (gn_uint32 j = 0; j < i; ++j) + gn_com_release(state->d3d_images[j]); + struct gn_unix_destroy_swapchain_args destroy_args; + destroy_args.slot = slot; + destroy_args.result = GN_UNIX_ERROR_UNAVAILABLE; + gn_unix_call(GN_UNIX_DESTROY_SWAPCHAIN, &destroy_args); + gn_zero_memory(state, sizeof(*state)); + return XR_ERROR_RUNTIME_FAILURE; + } + state->d3d_images[i] = texture; + } + } else if (gn_gfx_api == GN_GFX_D3D12) { + GnVkd3dCreateResource create_resource = + (GnVkd3dCreateResource)gn_com_method(gn_vkd3d_device_ext, 10); + GnD3D12ResourceDesc1 desc; + gn_zero_memory(&desc, sizeof(desc)); + desc.Dimension = 3; + desc.Width = createInfo->width; + desc.Height = createInfo->height; + desc.DepthOrArraySize = (unsigned short)createInfo->arraySize; + desc.MipLevels = (unsigned short)createInfo->mipCount; + desc.Format = (int)createInfo->format; + desc.SampleDesc.Count = createInfo->sampleCount; + if (createInfo->usageFlags & XR_SWAPCHAIN_USAGE_COLOR_ATTACHMENT_BIT) + desc.Flags |= 0x1; + if (createInfo->usageFlags & XR_SWAPCHAIN_USAGE_UNORDERED_ACCESS_BIT) + desc.Flags |= 0x4; + for (gn_uint32 i = 0; i < args.image_count; ++i) { + ID3D12Resource* resource = NULL; + if (!create_resource || + create_resource(gn_vkd3d_device_ext, &desc, + state->images[i], &resource) < 0 || + !resource) { + for (gn_uint32 j = 0; j < i; ++j) + gn_com_release(state->d3d_images[j]); + struct gn_unix_destroy_swapchain_args destroy_args; + destroy_args.slot = slot; + destroy_args.result = GN_UNIX_ERROR_UNAVAILABLE; + gn_unix_call(GN_UNIX_DESTROY_SWAPCHAIN, &destroy_args); + gn_zero_memory(state, sizeof(*state)); + return XR_ERROR_RUNTIME_FAILURE; + } + state->d3d_images[i] = resource; + } + } + *swapchain = (XrSwapchain)(GN_SWAPCHAIN_BASE | slot); + { + char command[64]; + gn_size n = gn_append( + command, sizeof(command), 0, "SWAPCHAIN_CREATE images="); + gn_append_i64( + command, sizeof(command), n, (long long)args.image_count); + gn_bridge_call(command, NULL, 0); + } + gn_log_num("xrCreateSwapchain images=", args.image_count); + return XR_SUCCESS; +} + +static XrResult XRAPI_CALL gn_xrDestroySwapchain(XrSwapchain swapchain) { + int slot = gn_swapchain_index(swapchain); + if (slot < 0) return XR_ERROR_HANDLE_INVALID; + for (gn_uint32 i = 0; i < gn_swapchains[slot].image_count; ++i) { + if (gn_swapchains[slot].d3d_images[i]) + gn_com_release(gn_swapchains[slot].d3d_images[i]); + } + struct gn_unix_destroy_swapchain_args args; + args.slot = (gn_u32)slot; + args.result = GN_UNIX_ERROR_UNAVAILABLE; + if (!gn_unix_call(GN_UNIX_DESTROY_SWAPCHAIN, &args) || + args.result != GN_UNIX_SUCCESS) return XR_ERROR_RUNTIME_FAILURE; + gn_zero_memory(&gn_swapchains[slot], sizeof(gn_swapchains[slot])); + gn_bridge_call("SWAPCHAIN_DESTROY", NULL, 0); + return XR_SUCCESS; +} + +static XrResult XRAPI_CALL gn_xrEnumerateSwapchainImages(XrSwapchain swapchain, gn_uint32 capacity, gn_uint32* count, XrSwapchainImageBaseHeader* images) { + int slot = gn_swapchain_index(swapchain); + if (slot < 0) return XR_ERROR_HANDLE_INVALID; + if (!count || (capacity && !images)) return XR_ERROR_VALIDATION_FAILURE; + GnSwapchain* state = &gn_swapchains[slot]; + *count = state->image_count; + if (!capacity) return XR_SUCCESS; + if (capacity < state->image_count) return XR_ERROR_SIZE_INSUFFICIENT; + if (gn_gfx_api == GN_GFX_VULKAN) { + for (gn_uint32 i = 0; i < state->image_count; ++i) { + XrSwapchainImageVulkanKHR* image = + (XrSwapchainImageVulkanKHR*)((unsigned char*)images + + i * sizeof(XrSwapchainImageVulkanKHR)); + if (image->type != XR_TYPE_SWAPCHAIN_IMAGE_VULKAN_KHR) { + return XR_ERROR_VALIDATION_FAILURE; + } + image->image = (VkImage)state->images[i]; + } + } else if (gn_gfx_api == GN_GFX_D3D11) { + for (gn_uint32 i = 0; i < state->image_count; ++i) { + XrSwapchainImageD3D11KHR* image = + (XrSwapchainImageD3D11KHR*)((unsigned char*)images + + i * sizeof(XrSwapchainImageD3D11KHR)); + if (image->type != XR_TYPE_SWAPCHAIN_IMAGE_D3D11_KHR) + return XR_ERROR_VALIDATION_FAILURE; + image->texture = (ID3D11Texture2D*)state->d3d_images[i]; + } + } else if (gn_gfx_api == GN_GFX_D3D12) { + for (gn_uint32 i = 0; i < state->image_count; ++i) { + XrSwapchainImageD3D12KHR* image = + (XrSwapchainImageD3D12KHR*)((unsigned char*)images + + i * sizeof(XrSwapchainImageD3D12KHR)); + if (image->type != XR_TYPE_SWAPCHAIN_IMAGE_D3D12_KHR) + return XR_ERROR_VALIDATION_FAILURE; + image->texture = (ID3D12Resource*)state->d3d_images[i]; + } + } else { + return XR_ERROR_FEATURE_UNSUPPORTED; + } + return XR_SUCCESS; +} + +static XrResult XRAPI_CALL gn_xrAcquireSwapchainImage(XrSwapchain swapchain, const XrSwapchainImageAcquireInfo* acquireInfo, gn_uint32* index) { + int slot = gn_swapchain_index(swapchain); + if (slot < 0) return XR_ERROR_HANDLE_INVALID; + if (!acquireInfo || acquireInfo->type != XR_TYPE_SWAPCHAIN_IMAGE_ACQUIRE_INFO || !index) + return XR_ERROR_VALIDATION_FAILURE; + GnSwapchain* state = &gn_swapchains[slot]; + if (state->acquire_count >= state->image_count) + return XR_ERROR_CALL_ORDER_INVALID; + for (gn_uint32 n = 0; n < state->image_count; ++n) { + gn_uint32 candidate = (state->next_image + n) % state->image_count; + if (state->image_state[candidate] == GN_IMAGE_AVAILABLE) { + state->image_state[candidate] = GN_IMAGE_ACQUIRED; + state->acquire_queue[ + (state->acquire_head + state->acquire_count) % GN_UNIX_MAX_IMAGES] = + candidate; + ++state->acquire_count; + state->next_image = (candidate + 1) % state->image_count; + *index = candidate; + return XR_SUCCESS; + } + } + return XR_ERROR_CALL_ORDER_INVALID; +} + +static XrResult XRAPI_CALL gn_xrWaitSwapchainImage(XrSwapchain swapchain, const XrSwapchainImageWaitInfo* waitInfo) { + int slot = gn_swapchain_index(swapchain); + if (slot < 0) return XR_ERROR_HANDLE_INVALID; + if (!waitInfo || waitInfo->type != XR_TYPE_SWAPCHAIN_IMAGE_WAIT_INFO || + (waitInfo->timeout < 0 && waitInfo->timeout != XR_INFINITE_DURATION)) + return XR_ERROR_VALIDATION_FAILURE; + GnSwapchain* state = &gn_swapchains[slot]; + if (!state->acquire_count) return XR_ERROR_CALL_ORDER_INVALID; + gn_uint32 index = state->acquire_queue[state->acquire_head]; + if (index >= state->image_count || state->image_state[index] != GN_IMAGE_ACQUIRED) { + return XR_ERROR_CALL_ORDER_INVALID; + } + if (state->submitted[index]) { + struct gn_unix_acquire_image_args args; + args.slot = (gn_u32)slot; + args.image_index = index; + args.timeout_ns = waitInfo->timeout; + args.result = GN_UNIX_ERROR_UNAVAILABLE; + if (!gn_unix_call(GN_UNIX_ACQUIRE_IMAGE, &args)) return XR_ERROR_RUNTIME_FAILURE; + if (args.result == GN_UNIX_ERROR_TIMEOUT) return XR_TIMEOUT_EXPIRED; + if (args.result != GN_UNIX_SUCCESS) return XR_ERROR_RUNTIME_FAILURE; + state->submitted[index] = 0; + } + state->image_state[index] = GN_IMAGE_WAITED; + return XR_SUCCESS; +} + +static XrResult XRAPI_CALL gn_xrReleaseSwapchainImage(XrSwapchain swapchain, const XrSwapchainImageReleaseInfo* releaseInfo) { + int slot = gn_swapchain_index(swapchain); + if (slot < 0) return XR_ERROR_HANDLE_INVALID; + if (!releaseInfo || releaseInfo->type != XR_TYPE_SWAPCHAIN_IMAGE_RELEASE_INFO) + return XR_ERROR_VALIDATION_FAILURE; + GnSwapchain* state = &gn_swapchains[slot]; + if (!state->acquire_count) return XR_ERROR_CALL_ORDER_INVALID; + gn_uint32 index = state->acquire_queue[state->acquire_head]; + if (index >= state->image_count || state->image_state[index] != GN_IMAGE_WAITED) { + return XR_ERROR_CALL_ORDER_INVALID; + } + state->image_state[index] = GN_IMAGE_AVAILABLE; + state->acquire_head = (state->acquire_head + 1) % GN_UNIX_MAX_IMAGES; + --state->acquire_count; + state->last_released_image = index; + state->last_released_valid = 1; + return XR_SUCCESS; +} + + + + + +static XrResult XRAPI_CALL gn_xrStringToPath(XrInstance instance, const char* pathString, XrPath* path) { + (void)instance; + if (!pathString || !path) return XR_ERROR_VALIDATION_FAILURE; + gn_paths_init(); + *path = gn_path_get_or_create(pathString); + return *path != XR_NULL_PATH ? XR_SUCCESS : XR_ERROR_PATH_FORMAT_INVALID; +} + +static XrResult XRAPI_CALL gn_xrPathToString(XrInstance instance, XrPath path, gn_uint32 capacity, gn_uint32* count, char* buffer) { + (void)instance; + const char* str = gn_path_string(path); + if (!str) return XR_ERROR_PATH_INVALID; + return gn_fill_string(str, capacity, count, buffer); +} + +static XrResult XRAPI_CALL gn_xrCreateActionSet(XrInstance instance, const XrActionSetCreateInfo* createInfo, XrActionSet* actionSet) { + if (instance != gn_instance || !actionSet || !createInfo) return XR_ERROR_HANDLE_INVALID; + if (gn_action_set_count >= GN_MAX_ACTION_SETS) return XR_ERROR_LIMIT_REACHED; + GnActionSet* record = &gn_action_sets[gn_action_set_count]; + record->used = 1; + record->attached = 0; + gn_copy(record->name, sizeof(record->name), createInfo->actionSetName); + *actionSet = (XrActionSet)(GN_ACTIONSET_BASE | gn_action_set_count); + ++gn_action_set_count; + gn_log2("xrCreateActionSet: ", createInfo->actionSetName); + return XR_SUCCESS; +} + +static XrResult XRAPI_CALL gn_xrDestroyActionSet(XrActionSet actionSet) { + int idx = gn_action_set_index(actionSet); + if (idx < 0) return XR_ERROR_HANDLE_INVALID; + gn_action_sets[idx].used = 0; + for (gn_uint32 i = 0; i < gn_action_count; ++i) { + if (gn_actions[i].used && gn_actions[i].action_set_idx == idx) gn_actions[i].used = 0; + } + return XR_SUCCESS; +} + +static XrResult XRAPI_CALL gn_xrCreateAction(XrActionSet actionSet, const XrActionCreateInfo* createInfo, XrAction* action) { + int set_idx = gn_action_set_index(actionSet); + if (!action || !createInfo) return XR_ERROR_VALIDATION_FAILURE; + if (set_idx < 0) return XR_ERROR_HANDLE_INVALID; + if (gn_action_sets[set_idx].attached) return XR_ERROR_ACTIONSETS_ALREADY_ATTACHED; + if (gn_action_count >= GN_MAX_ACTIONS) return XR_ERROR_LIMIT_REACHED; + GnAction* record = &gn_actions[gn_action_count]; + record->used = 1; + record->action_set_idx = set_idx; + record->type = createInfo->actionType; + record->component[0] = GN_COMP_NONE; + record->component[1] = GN_COMP_NONE; + record->binding_priority[0] = 0; + record->binding_priority[1] = 0; + record->active_hands = 0; + gn_copy(record->name, sizeof(record->name), createInfo->actionName); + *action = (XrAction)(GN_ACTION_BASE | gn_action_count); + ++gn_action_count; + return XR_SUCCESS; +} + +static XrResult XRAPI_CALL gn_xrDestroyAction(XrAction action) { + int idx = gn_action_index(action); + if (idx >= 0) gn_actions[idx].used = 0; + return XR_SUCCESS; +} + +static XrResult XRAPI_CALL gn_xrSuggestInteractionProfileBindings( + XrInstance instance, + const XrInteractionProfileSuggestedBinding* suggestedBindings) { + if (instance != gn_instance) return XR_ERROR_HANDLE_INVALID; + if (!suggestedBindings) return XR_ERROR_VALIDATION_FAILURE; + + const char* profile = gn_path_string(suggestedBindings->interactionProfile); + const int priority = gn_interaction_profile_priority(profile); + gn_log2("xrSuggestInteractionProfileBindings: ", profile ? profile : "?"); + + for (gn_uint32 i = 0; i < suggestedBindings->countSuggestedBindings; ++i) { + const XrActionSuggestedBinding* binding = &suggestedBindings->suggestedBindings[i]; + int action_idx = gn_action_index(binding->action); + const char* path = gn_path_string(binding->binding); + if (action_idx < 0 || !path) continue; + int hand = -1; + if (gn_starts_with(path, "/user/hand/left")) hand = 0; + else if (gn_starts_with(path, "/user/hand/right")) hand = 1; + int comp = gn_component_from_binding(path); + if (comp == GN_COMP_NONE) { + gn_log2(" unmapped binding: ", path); + continue; + } + if (hand >= 0) { + if (priority >= gn_actions[action_idx].binding_priority[hand]) { + gn_actions[action_idx].component[hand] = (unsigned char)comp; + gn_actions[action_idx].binding_priority[hand] = (unsigned char)priority; + } + } else { + for (int candidate = 0; candidate < 2; ++candidate) { + if (priority >= gn_actions[action_idx].binding_priority[candidate]) { + gn_actions[action_idx].component[candidate] = (unsigned char)comp; + gn_actions[action_idx].binding_priority[candidate] = (unsigned char)priority; + } + } + } + } + return XR_SUCCESS; +} + +static XrResult XRAPI_CALL gn_xrAttachSessionActionSets(XrSession session, const XrSessionActionSetsAttachInfo* attachInfo) { + if (session != gn_session) return XR_ERROR_HANDLE_INVALID; + if (!attachInfo || (attachInfo->countActionSets != 0 && !attachInfo->actionSets)) { + return XR_ERROR_VALIDATION_FAILURE; + } + if (gn_action_sets_attached) return XR_ERROR_ACTIONSETS_ALREADY_ATTACHED; + for (gn_uint32 i = 0; i < attachInfo->countActionSets; ++i) { + if (gn_action_set_index(attachInfo->actionSets[i]) < 0) return XR_ERROR_HANDLE_INVALID; + } + for (gn_uint32 i = 0; i < attachInfo->countActionSets; ++i) { + gn_action_sets[gn_action_set_index(attachInfo->actionSets[i])].attached = 1; + } + gn_action_sets_attached = 1; + gn_interaction_profile_event_pending = 1; + gn_log_line("xrAttachSessionActionSets"); + return XR_SUCCESS; +} + +static XrResult XRAPI_CALL gn_xrSyncActions(XrSession session, const XrActionsSyncInfo* syncInfo) { + if (session != gn_session) return XR_ERROR_HANDLE_INVALID; + if (!syncInfo || (syncInfo->countActiveActionSets != 0 && !syncInfo->activeActionSets)) { + return XR_ERROR_VALIDATION_FAILURE; + } + if (!gn_action_sets_attached) return XR_ERROR_ACTIONSET_NOT_ATTACHED; + for (gn_uint32 i = 0; i < gn_action_count; ++i) gn_actions[i].active_hands = 0; + for (gn_uint32 i = 0; i < syncInfo->countActiveActionSets; ++i) { + const XrActiveActionSet* active = &syncInfo->activeActionSets[i]; + int set_idx = gn_action_set_index(active->actionSet); + if (set_idx < 0) return XR_ERROR_HANDLE_INVALID; + if (!gn_action_sets[set_idx].attached) return XR_ERROR_ACTIONSET_NOT_ATTACHED; + int hand = gn_hand_from_path(active->subactionPath); + unsigned char hand_mask = hand < 0 ? 3u : (unsigned char)(1u << hand); + for (gn_uint32 action_idx = 0; action_idx < gn_action_count; ++action_idx) { + if (gn_actions[action_idx].used && gn_actions[action_idx].action_set_idx == set_idx) { + gn_actions[action_idx].active_hands |= hand_mask; + } + } + } + gn_refresh_hand(0); + gn_refresh_hand(1); + for (int hand = 0; hand < 2; ++hand) { + XrPosef pose; + gn_write_pose(&pose, gn_hands[hand].grip); + gn_update_pose_velocity( + &pose, + gn_next_display_time, + &gn_last_hand_pose[hand], + &gn_last_hand_time[hand], + gn_hand_linear_velocity[hand], + gn_hand_angular_velocity[hand], + 0); + } + gn_update_change_tracking(gn_next_display_time); + return XR_SUCCESS; +} + +static XrResult XRAPI_CALL gn_xrGetCurrentInteractionProfile( + XrSession session, + XrPath topLevelUserPath, + XrInteractionProfileState* interactionProfile) { + (void)topLevelUserPath; + if (session != gn_session || !interactionProfile) return XR_ERROR_HANDLE_INVALID; + interactionProfile->interactionProfile = gn_path_get_or_create("/interaction_profiles/oculus/touch_controller"); + return XR_SUCCESS; +} + + +static int gn_resolve_action(const XrActionStateGetInfo* getInfo, int* out_hand, int* out_comp) { + int action_idx = gn_action_index(getInfo->action); + if (action_idx < 0) return 0; + const GnAction* action = &gn_actions[action_idx]; + int hand = gn_hand_from_path(getInfo->subactionPath); + if (getInfo->subactionPath != XR_NULL_PATH && hand < 0) return 0; + if (hand < 0) hand = gn_action_default_hand(action); + *out_hand = hand; + *out_comp = action->component[hand]; + return 1; +} + +static int gn_action_is_active(XrAction action, int hand, int comp) { + int action_idx = gn_action_index(action); + if (action_idx < 0 || hand < 0 || hand > 1 || comp == GN_COMP_NONE) return 0; + return (gn_actions[action_idx].active_hands & (1u << hand)) != 0 && gn_hands[hand].active; +} + +static XrResult XRAPI_CALL gn_xrGetActionStateBoolean( + XrSession session, + const XrActionStateGetInfo* getInfo, + XrActionStateBoolean* state) { + int hand = 0, comp = GN_COMP_NONE; + if (session != gn_session || !state || !getInfo) return XR_ERROR_HANDLE_INVALID; + if (!gn_resolve_action(getInfo, &hand, &comp)) return XR_ERROR_HANDLE_INVALID; + float value = gn_comp_value(hand, comp); + state->currentState = value > 0.7f ? XR_TRUE : XR_FALSE; + state->changedSinceLastSync = gn_comp_changed[hand][comp] ? XR_TRUE : XR_FALSE; + state->lastChangeTime = gn_comp_change_time[hand][comp] ? gn_comp_change_time[hand][comp] : gn_last_sync_time; + state->isActive = gn_action_is_active(getInfo->action, hand, comp) ? XR_TRUE : XR_FALSE; + if (!state->isActive) { + state->currentState = XR_FALSE; + state->changedSinceLastSync = XR_FALSE; + } + return XR_SUCCESS; +} + +static XrResult XRAPI_CALL gn_xrGetActionStateFloat( + XrSession session, + const XrActionStateGetInfo* getInfo, + XrActionStateFloat* state) { + int hand = 0, comp = GN_COMP_NONE; + if (session != gn_session || !state || !getInfo) return XR_ERROR_HANDLE_INVALID; + if (!gn_resolve_action(getInfo, &hand, &comp)) return XR_ERROR_HANDLE_INVALID; + state->currentState = gn_comp_value(hand, comp); + state->changedSinceLastSync = gn_comp_changed[hand][comp] ? XR_TRUE : XR_FALSE; + state->lastChangeTime = gn_comp_change_time[hand][comp] ? gn_comp_change_time[hand][comp] : gn_last_sync_time; + state->isActive = gn_action_is_active(getInfo->action, hand, comp) ? XR_TRUE : XR_FALSE; + if (!state->isActive) { + state->currentState = 0.0f; + state->changedSinceLastSync = XR_FALSE; + } + return XR_SUCCESS; +} + +static XrResult XRAPI_CALL gn_xrGetActionStateVector2f( + XrSession session, + const XrActionStateGetInfo* getInfo, + XrActionStateVector2f* state) { + int hand = 0, comp = GN_COMP_NONE; + if (session != gn_session || !state || !getInfo) return XR_ERROR_HANDLE_INVALID; + if (!gn_resolve_action(getInfo, &hand, &comp)) return XR_ERROR_HANDLE_INVALID; + state->currentState.x = gn_hands[hand].sx; + state->currentState.y = gn_hands[hand].sy; + state->changedSinceLastSync = + (gn_comp_changed[hand][GN_COMP_STICK_X] || gn_comp_changed[hand][GN_COMP_STICK_Y] || gn_comp_changed[hand][GN_COMP_STICK]) + ? XR_TRUE : XR_FALSE; + state->lastChangeTime = gn_last_sync_time; + state->isActive = gn_action_is_active(getInfo->action, hand, comp) ? XR_TRUE : XR_FALSE; + if (!state->isActive) { + state->currentState.x = 0.0f; + state->currentState.y = 0.0f; + state->changedSinceLastSync = XR_FALSE; + } + return XR_SUCCESS; +} + +static XrResult XRAPI_CALL gn_xrGetActionStatePose( + XrSession session, + const XrActionStateGetInfo* getInfo, + XrActionStatePose* state) { + int hand = 0, comp = GN_COMP_NONE; + if (session != gn_session || !state || !getInfo) return XR_ERROR_HANDLE_INVALID; + if (!gn_resolve_action(getInfo, &hand, &comp)) return XR_ERROR_HANDLE_INVALID; + state->isActive = gn_action_is_active(getInfo->action, hand, comp) ? XR_TRUE : XR_FALSE; + return XR_SUCCESS; +} + +static XrResult XRAPI_CALL gn_xrEnumerateBoundSourcesForAction( + XrSession session, + const XrBoundSourcesForActionEnumerateInfo* enumerateInfo, + gn_uint32 capacity, + gn_uint32* count, + XrPath* sources) { + XrPath resolved[2]; + gn_uint32 resolved_count = 0; + if (session != gn_session) return XR_ERROR_HANDLE_INVALID; + if (!enumerateInfo) return XR_ERROR_VALIDATION_FAILURE; + int action_idx = gn_action_index(enumerateInfo->action); + if (action_idx < 0) return XR_ERROR_HANDLE_INVALID; + for (int hand = 0; hand < 2; ++hand) { + int comp = gn_actions[action_idx].component[hand]; + const char* suffix = NULL; + switch (comp) { + case GN_COMP_PRIMARY: suffix = hand == 0 ? "/input/x/click" : "/input/a/click"; break; + case GN_COMP_SECONDARY: suffix = hand == 0 ? "/input/y/click" : "/input/b/click"; break; + case GN_COMP_STICK_CLICK: suffix = "/input/thumbstick/click"; break; + case GN_COMP_MENU: suffix = "/input/menu/click"; break; + case GN_COMP_TRIGGER: suffix = "/input/trigger/value"; break; + case GN_COMP_SQUEEZE: suffix = "/input/squeeze/value"; break; + case GN_COMP_STICK: suffix = "/input/thumbstick"; break; + case GN_COMP_STICK_X: suffix = "/input/thumbstick/x"; break; + case GN_COMP_STICK_Y: suffix = "/input/thumbstick/y"; break; + case GN_COMP_GRIP_POSE: suffix = "/input/grip/pose"; break; + case GN_COMP_AIM_POSE: suffix = "/input/aim/pose"; break; + case GN_COMP_HAPTIC: suffix = "/output/haptic"; break; + default: break; + } + if (suffix) { + char path[GN_PATH_LEN]; + gn_size n = gn_append(path, sizeof(path), 0, hand == 0 ? "/user/hand/left" : "/user/hand/right"); + gn_append(path, sizeof(path), n, suffix); + resolved[resolved_count++] = gn_path_get_or_create(path); + } + } + XrResult r = gn_copy_props(resolved_count, capacity, count); + if (XR_SUCCEEDED(r) && capacity != 0) { + if (!sources) return XR_ERROR_VALIDATION_FAILURE; + for (gn_uint32 i = 0; i < resolved_count; ++i) sources[i] = resolved[i]; + } + return r; +} + +static XrResult XRAPI_CALL gn_xrGetInputSourceLocalizedName( + XrSession session, + const XrInputSourceLocalizedNameGetInfo* getInfo, + gn_uint32 capacity, + gn_uint32* count, + char* buffer) { + (void)getInfo; + if (session != gn_session) return XR_ERROR_HANDLE_INVALID; + return gn_fill_string("GameNativeVR Touch", capacity, count, buffer); +} + +static XrResult XRAPI_CALL gn_xrApplyHapticFeedback( + XrSession session, + const XrHapticActionInfo* hapticActionInfo, + const XrHapticBaseHeader* hapticFeedback) { + if (session != gn_session) return XR_ERROR_HANDLE_INVALID; + if (!hapticActionInfo || !hapticFeedback) return XR_ERROR_VALIDATION_FAILURE; + + int hand = gn_hand_from_path(hapticActionInfo->subactionPath); + if (hand < 0) { + int action_idx = gn_action_index(hapticActionInfo->action); + hand = action_idx >= 0 ? gn_action_default_hand(&gn_actions[action_idx]) : 0; + } + + if (hapticFeedback->type == XR_TYPE_HAPTIC_VIBRATION) { + const XrHapticVibration* vibration = (const XrHapticVibration*)hapticFeedback; + char cmd[160]; + gn_size n = gn_append(cmd, sizeof(cmd), 0, "HAPTIC hand="); + n = gn_append_i64(cmd, sizeof(cmd), n, hand); + n = gn_append(cmd, sizeof(cmd), n, " amp="); + n = gn_append_i64(cmd, sizeof(cmd), n, gn_float_to_micro(vibration->amplitude)); + n = gn_append(cmd, sizeof(cmd), n, " dur="); + n = gn_append_i64(cmd, sizeof(cmd), n, vibration->duration); + n = gn_append(cmd, sizeof(cmd), n, " freq="); + n = gn_append_i64(cmd, sizeof(cmd), n, gn_float_to_micro(vibration->frequency)); + gn_bridge_call(cmd, NULL, 0); + } + return XR_SUCCESS; +} + +static XrResult XRAPI_CALL gn_xrStopHapticFeedback(XrSession session, const XrHapticActionInfo* hapticActionInfo) { + if (session != gn_session) return XR_ERROR_HANDLE_INVALID; + if (hapticActionInfo) { + int hand = gn_hand_from_path(hapticActionInfo->subactionPath); + char cmd[64]; + gn_size n = gn_append(cmd, sizeof(cmd), 0, "HAPTIC hand="); + n = gn_append_i64(cmd, sizeof(cmd), n, hand < 0 ? 0 : hand); + n = gn_append(cmd, sizeof(cmd), n, " amp=0 dur=0 freq=0"); + gn_bridge_call(cmd, NULL, 0); + } + return XR_SUCCESS; +} + + + + + +GN_EXPORT XrResult XRAPI_CALL xrGetInstanceProcAddr(XrInstance instance, const char* name, PFN_xrVoidFunction* function) { + (void)instance; + if (!name || !function) return XR_ERROR_VALIDATION_FAILURE; + *function = NULL; +#define GN_PROC(n) if (gn_streq(name, #n)) { *function = (PFN_xrVoidFunction)gn_##n; return XR_SUCCESS; } + GN_PROC(xrEnumerateInstanceExtensionProperties) + GN_PROC(xrCreateInstance) + GN_PROC(xrDestroyInstance) + GN_PROC(xrGetInstanceProperties) + GN_PROC(xrPollEvent) + GN_PROC(xrResultToString) + GN_PROC(xrStructureTypeToString) + GN_PROC(xrGetSystem) + GN_PROC(xrGetSystemProperties) + GN_PROC(xrEnumerateEnvironmentBlendModes) + GN_PROC(xrEnumerateViewConfigurations) + GN_PROC(xrGetViewConfigurationProperties) + GN_PROC(xrEnumerateViewConfigurationViews) + GN_PROC(xrCreateSession) + GN_PROC(xrDestroySession) + GN_PROC(xrBeginSession) + GN_PROC(xrEndSession) + GN_PROC(xrRequestExitSession) + GN_PROC(xrEnumerateReferenceSpaces) + GN_PROC(xrCreateReferenceSpace) + GN_PROC(xrGetReferenceSpaceBoundsRect) + GN_PROC(xrDestroySpace) + GN_PROC(xrCreateActionSpace) + GN_PROC(xrLocateSpace) + GN_PROC(xrLocateSpaces) + GN_PROC(xrWaitFrame) + GN_PROC(xrBeginFrame) + GN_PROC(xrEndFrame) + GN_PROC(xrLocateViews) + GN_PROC(xrEnumerateSwapchainFormats) + GN_PROC(xrGetD3D11GraphicsRequirementsKHR) + GN_PROC(xrGetD3D12GraphicsRequirementsKHR) + GN_PROC(xrGetVulkanInstanceExtensionsKHR) + GN_PROC(xrGetVulkanDeviceExtensionsKHR) + GN_PROC(xrGetVulkanGraphicsDeviceKHR) + GN_PROC(xrGetVulkanGraphicsRequirementsKHR) + GN_PROC(xrGetVulkanGraphicsDevice2KHR) + GN_PROC(xrGetVulkanGraphicsRequirements2KHR) + GN_PROC(xrCreateVulkanInstanceKHR) + GN_PROC(xrCreateVulkanDeviceKHR) + GN_PROC(xrCreateSwapchain) + GN_PROC(xrDestroySwapchain) + GN_PROC(xrEnumerateSwapchainImages) + GN_PROC(xrAcquireSwapchainImage) + GN_PROC(xrWaitSwapchainImage) + GN_PROC(xrReleaseSwapchainImage) + GN_PROC(xrStringToPath) + GN_PROC(xrPathToString) + GN_PROC(xrCreateActionSet) + GN_PROC(xrDestroyActionSet) + GN_PROC(xrCreateAction) + GN_PROC(xrDestroyAction) + GN_PROC(xrSuggestInteractionProfileBindings) + GN_PROC(xrAttachSessionActionSets) + GN_PROC(xrSyncActions) + GN_PROC(xrGetCurrentInteractionProfile) + GN_PROC(xrGetActionStateBoolean) + GN_PROC(xrGetActionStateFloat) + GN_PROC(xrGetActionStateVector2f) + GN_PROC(xrGetActionStatePose) + GN_PROC(xrEnumerateBoundSourcesForAction) + GN_PROC(xrGetInputSourceLocalizedName) + GN_PROC(xrApplyHapticFeedback) + GN_PROC(xrStopHapticFeedback) +#undef GN_PROC + if (gn_streq(name, "xrLocateSpacesKHR")) { + *function = (PFN_xrVoidFunction)gn_xrLocateSpaces; + return XR_SUCCESS; + } + if (gn_streq(name, "xrGetInstanceProcAddr")) { + *function = (PFN_xrVoidFunction)xrGetInstanceProcAddr; + return XR_SUCCESS; + } + gn_log2("unsupported function requested: ", name); + return XR_ERROR_FUNCTION_UNSUPPORTED; +} + +GN_EXPORT XrResult XRAPI_CALL xrNegotiateLoaderRuntimeInterface( + const XrNegotiateLoaderInfo* loaderInfo, + XrNegotiateRuntimeRequest* runtimeRequest) { + if (!loaderInfo || !runtimeRequest) return XR_ERROR_VALIDATION_FAILURE; + if (loaderInfo->minInterfaceVersion > XR_CURRENT_LOADER_RUNTIME_VERSION || + loaderInfo->maxInterfaceVersion < XR_CURRENT_LOADER_RUNTIME_VERSION) { + return XR_ERROR_INITIALIZATION_FAILED; + } + runtimeRequest->structType = XR_LOADER_INTERFACE_STRUCT_RUNTIME_REQUEST; + runtimeRequest->structVersion = XR_RUNTIME_INFO_STRUCT_VERSION; + runtimeRequest->structSize = sizeof(*runtimeRequest); + runtimeRequest->runtimeInterfaceVersion = XR_CURRENT_LOADER_RUNTIME_VERSION; + runtimeRequest->runtimeApiVersion = XR_MAKE_VERSION(1, 0, 0); + runtimeRequest->getInstanceProcAddr = xrGetInstanceProcAddr; + gn_log_line("runtime negotiated with loader"); + return XR_SUCCESS; +} + +GN_EXPORT int DllMain(void* module, unsigned long reason, void* reserved) { + (void)module; + (void)reason; + (void)reserved; + return 1; +} diff --git a/app/src/main/windows/openxr_runtime/gamenative_openxr_runtime_x64.def b/app/src/main/windows/openxr_runtime/gamenative_openxr_runtime_x64.def new file mode 100644 index 0000000000..40b9b2df87 --- /dev/null +++ b/app/src/main/windows/openxr_runtime/gamenative_openxr_runtime_x64.def @@ -0,0 +1,4 @@ +LIBRARY gamenative_openxr_runtime64.dll +EXPORTS + xrGetInstanceProcAddr + xrNegotiateLoaderRuntimeInterface diff --git a/app/src/main/windows/openxr_runtime/gamenative_openxr_runtime_x86.def b/app/src/main/windows/openxr_runtime/gamenative_openxr_runtime_x86.def new file mode 100644 index 0000000000..a211551184 --- /dev/null +++ b/app/src/main/windows/openxr_runtime/gamenative_openxr_runtime_x86.def @@ -0,0 +1,4 @@ +LIBRARY gamenative_openxr_runtime32.dll +EXPORTS + xrGetInstanceProcAddr = xrGetInstanceProcAddr@16 + xrNegotiateLoaderRuntimeInterface = xrNegotiateLoaderRuntimeInterface@8 diff --git a/app/src/main/windows/openxr_runtime/gamenative_openxr_unix.h b/app/src/main/windows/openxr_runtime/gamenative_openxr_unix.h new file mode 100644 index 0000000000..d3b4bcd627 --- /dev/null +++ b/app/src/main/windows/openxr_runtime/gamenative_openxr_unix.h @@ -0,0 +1,130 @@ +#pragma once + + + + + +#if defined(_MSC_VER) +typedef unsigned __int32 gn_u32; +typedef signed __int32 gn_i32; +typedef unsigned __int64 gn_u64; +typedef signed __int64 gn_i64; +#else +typedef unsigned int gn_u32; +typedef signed int gn_i32; +typedef unsigned long long gn_u64; +typedef signed long long gn_i64; +#endif + +#define GN_UNIX_ABI_VERSION 5u +#define GN_UNIX_MAX_SWAPCHAINS 32u +#define GN_UNIX_MAX_IMAGES 4u + +enum gn_unix_call_code { + GN_UNIX_INIT = 0, + GN_UNIX_SET_VULKAN_CONTEXT, + GN_UNIX_CREATE_SWAPCHAIN, + GN_UNIX_DESTROY_SWAPCHAIN, + GN_UNIX_ACQUIRE_IMAGE, + GN_UNIX_SUBMIT_IMAGE, + GN_UNIX_SUBMIT_STEREO, + GN_UNIX_CALL_COUNT +}; + +enum gn_unix_result { + GN_UNIX_SUCCESS = 0, + GN_UNIX_ERROR_ARGUMENT = -1, + GN_UNIX_ERROR_UNAVAILABLE = -2, + GN_UNIX_ERROR_VULKAN = -3, + GN_UNIX_ERROR_TRANSPORT = -4, + GN_UNIX_ERROR_TIMEOUT = -5 +}; + +enum gn_unix_vulkan_diagnostic_flag { + GN_UNIX_VK_DIAG_PHYSICAL_DEVICE = 1u << 0, + GN_UNIX_VK_DIAG_DEVICE = 1u << 1, + GN_UNIX_VK_DIAG_QUEUE = 1u << 2, + GN_UNIX_VK_DIAG_VULKAN_LIBRARY = 1u << 3, + GN_UNIX_VK_DIAG_GET_DEVICE_PROC_ADDR = 1u << 4, + GN_UNIX_VK_DIAG_CREATE_IMAGE = 1u << 5, + GN_UNIX_VK_DIAG_GET_MEMORY_FD = 1u << 6 +}; + +#pragma pack(push, 1) +struct gn_unix_init_args { + gn_u32 abi_version; + gn_i32 result; +}; + +struct gn_unix_vulkan_context_args { + gn_u64 client_physical_device; + gn_u64 client_device; + gn_u64 client_queue; + gn_u32 queue_family_index; + gn_u32 queue_index; + gn_u32 handles_are_host; + gn_u32 diagnostic_flags; + gn_i32 result; +}; + +struct gn_unix_create_swapchain_args { + gn_u32 slot; + gn_u32 width; + gn_u32 height; + gn_u32 array_size; + gn_u32 mip_count; + gn_u32 sample_count; + gn_i64 format; + gn_u64 usage; + gn_u32 image_count; + gn_u64 images[GN_UNIX_MAX_IMAGES]; + gn_i32 result; +}; + +struct gn_unix_destroy_swapchain_args { + gn_u32 slot; + gn_i32 result; +}; + +struct gn_unix_acquire_image_args { + gn_u32 slot; + gn_u32 image_index; + gn_i64 timeout_ns; + gn_i32 result; +}; + +struct gn_unix_submit_view_args { + gn_u32 slot; + gn_u32 image_index; + gn_u32 eye; + gn_u32 array_index; + gn_i32 rect_x; + gn_i32 rect_y; + gn_u32 rect_width; + gn_u32 rect_height; + gn_i64 orientation_micro[4]; + gn_i64 position_micro[3]; + gn_i64 fov_micro[4]; +}; + +struct gn_unix_submit_image_args { + gn_u32 slot; + gn_u32 image_index; + gn_u32 eye; + gn_u32 array_index; + gn_i32 rect_x; + gn_i32 rect_y; + gn_u32 rect_width; + gn_u32 rect_height; + gn_i64 orientation_micro[4]; + gn_i64 position_micro[3]; + gn_i64 fov_micro[4]; + gn_i32 result; +}; + +struct gn_unix_submit_stereo_args { + gn_u32 view_count; + struct gn_unix_submit_view_args views[2]; + gn_i32 result; +}; +#pragma pack(pop) diff --git a/app/src/main/windows/openxr_runtime/gamenative_openxr_unix_abi.h b/app/src/main/windows/openxr_runtime/gamenative_openxr_unix_abi.h new file mode 100644 index 0000000000..f5b601f029 --- /dev/null +++ b/app/src/main/windows/openxr_runtime/gamenative_openxr_unix_abi.h @@ -0,0 +1,114 @@ +#ifndef GAMENATIVE_OPENXR_UNIX_ABI_H +#define GAMENATIVE_OPENXR_UNIX_ABI_H + +#include + +#define GAMENATIVE_XR_UNIX_ABI_VERSION 2u +#define GAMENATIVE_XR_MAX_SWAPCHAINS 32u +#define GAMENATIVE_XR_MAX_IMAGES 4u +#define GAMENATIVE_XR_MAX_VIEWS 2u + +#pragma pack(push, 1) +typedef struct gamenative_xr_unix_header { + uint32_t abi_version; + uint32_t operation; + uint32_t payload_size; + int32_t result; +} gamenative_xr_unix_header; + +typedef struct gamenative_xr_vulkan_context { + gamenative_xr_unix_header header; + uint64_t physical_device; + uint64_t device; + uint64_t queue; + uint32_t queue_family; + uint32_t queue_index; + uint32_t host_handles; + uint32_t reserved; +} gamenative_xr_vulkan_context; + +typedef struct gamenative_xr_swapchain_create { + gamenative_xr_unix_header header; + uint32_t swapchain; + uint32_t width; + uint32_t height; + uint32_t format; + uint32_t image_count; + uint32_t array_size; + uint32_t usage; + uint32_t reserved; +} gamenative_xr_swapchain_create; + +typedef struct gamenative_xr_swapchain_destroy { + gamenative_xr_unix_header header; + uint32_t swapchain; + uint32_t reserved; +} gamenative_xr_swapchain_destroy; + +typedef struct gamenative_xr_image_acquire { + gamenative_xr_unix_header header; + uint32_t swapchain; + uint32_t image_index; + uint32_t slot; + uint32_t timeout_ms; + uint64_t image_handle; +} gamenative_xr_image_acquire; + +typedef struct gamenative_xr_image_copy { + gamenative_xr_unix_header header; + uint32_t swapchain; + uint32_t image_index; + uint64_t source_image; + uint32_t source_layout; + uint32_t array_index; + int32_t crop_x; + int32_t crop_y; + int32_t crop_width; + int32_t crop_height; +} gamenative_xr_image_copy; + +typedef struct gamenative_xr_view_submission { + uint32_t swapchain; + uint32_t slot; + uint32_t image_index; + uint32_t eye; + uint32_t array_index; + int32_t crop_x; + int32_t crop_y; + int32_t crop_width; + int32_t crop_height; + int32_t orientation[4]; + int32_t position[3]; + int32_t fov[4]; +} gamenative_xr_view_submission; + +typedef struct gamenative_xr_stereo_submission { + gamenative_xr_unix_header header; + uint64_t frame_id; + uint32_t view_count; + uint32_t reserved; + gamenative_xr_view_submission views[GAMENATIVE_XR_MAX_VIEWS]; +} gamenative_xr_stereo_submission; +#pragma pack(pop) + +enum gamenative_xr_unix_operation { + GAMENATIVE_XR_UNIX_INITIALIZE = 1, + GAMENATIVE_XR_UNIX_SET_VULKAN_CONTEXT = 2, + GAMENATIVE_XR_UNIX_CREATE_SWAPCHAIN = 3, + GAMENATIVE_XR_UNIX_DESTROY_SWAPCHAIN = 4, + GAMENATIVE_XR_UNIX_ACQUIRE_IMAGE = 5, + GAMENATIVE_XR_UNIX_SUBMIT_VIEW = 6, + GAMENATIVE_XR_UNIX_SUBMIT_STEREO = 7, + GAMENATIVE_XR_UNIX_COPY_IMAGE = 8 +}; + +enum gamenative_xr_unix_result { + GAMENATIVE_XR_UNIX_OK = 0, + GAMENATIVE_XR_UNIX_INVALID_ARGUMENT = -1, + GAMENATIVE_XR_UNIX_UNAVAILABLE = -2, + GAMENATIVE_XR_UNIX_VULKAN_ERROR = -3, + GAMENATIVE_XR_UNIX_TRANSPORT_ERROR = -4, + GAMENATIVE_XR_UNIX_TIMEOUT = -5 +}; + +#endif diff --git a/app/src/main/windows/openxr_runtime/kernel32_x64.def b/app/src/main/windows/openxr_runtime/kernel32_x64.def new file mode 100644 index 0000000000..58e6fe5a9f --- /dev/null +++ b/app/src/main/windows/openxr_runtime/kernel32_x64.def @@ -0,0 +1,12 @@ +LIBRARY KERNEL32.dll +EXPORTS + CreateFileA + WriteFile + CloseHandle + GetEnvironmentVariableA + OutputDebugStringA + LoadLibraryA + GetProcAddress + GetLastError + FreeLibrary + ExitProcess diff --git a/app/src/main/windows/openxr_runtime/kernel32_x86.def b/app/src/main/windows/openxr_runtime/kernel32_x86.def new file mode 100644 index 0000000000..2c8a5e5188 --- /dev/null +++ b/app/src/main/windows/openxr_runtime/kernel32_x86.def @@ -0,0 +1,12 @@ +LIBRARY KERNEL32.dll +EXPORTS + CreateFileA@28 + WriteFile@20 + CloseHandle@4 + GetEnvironmentVariableA@12 + OutputDebugStringA@4 + LoadLibraryA@4 + GetProcAddress@8 + GetLastError@0 + FreeLibrary@4 + ExitProcess@4 diff --git a/app/src/main/windows/openxr_runtime/ntdll_x64.def b/app/src/main/windows/openxr_runtime/ntdll_x64.def new file mode 100644 index 0000000000..17ada6bcd9 --- /dev/null +++ b/app/src/main/windows/openxr_runtime/ntdll_x64.def @@ -0,0 +1,4 @@ +LIBRARY ntdll.dll +EXPORTS + NtQueryVirtualMemory + __wine_unix_call_dispatcher DATA diff --git a/app/src/main/windows/openxr_runtime/ntdll_x86.def b/app/src/main/windows/openxr_runtime/ntdll_x86.def new file mode 100644 index 0000000000..476c3696b3 --- /dev/null +++ b/app/src/main/windows/openxr_runtime/ntdll_x86.def @@ -0,0 +1,4 @@ +LIBRARY ntdll.dll +EXPORTS + NtQueryVirtualMemory@24 + __wine_unix_call_dispatcher DATA diff --git a/app/src/main/windows/openxr_runtime/unix/CMakeLists.txt b/app/src/main/windows/openxr_runtime/unix/CMakeLists.txt new file mode 100644 index 0000000000..84c6908286 --- /dev/null +++ b/app/src/main/windows/openxr_runtime/unix/CMakeLists.txt @@ -0,0 +1,8 @@ +cmake_minimum_required(VERSION 3.22) +project(gamenative_xr_unixbridge C) + +add_library(gamenative_xr_unixbridge SHARED gamenative_openxr_unix.c) +target_include_directories(gamenative_xr_unixbridge PRIVATE ..) +target_link_libraries(gamenative_xr_unixbridge PRIVATE android dl log vulkan) +target_compile_options(gamenative_xr_unixbridge PRIVATE -Wall -Wextra -Werror) +set_target_properties(gamenative_xr_unixbridge PROPERTIES PREFIX "" OUTPUT_NAME "gamenative_xr_unixbridge") diff --git a/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c b/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c new file mode 100644 index 0000000000..2cbd61111e --- /dev/null +++ b/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c @@ -0,0 +1,1566 @@ +#define _GNU_SOURCE +#include "../gamenative_openxr_unix.h" + +#if defined(__ANDROID__) +#define VK_USE_PLATFORM_ANDROID_KHR 1 +#include +#endif +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define GN_FOURCC(a, b, c, d) \ + ((uint32_t)(a) | ((uint32_t)(b) << 8) | \ + ((uint32_t)(c) << 16) | ((uint32_t)(d) << 24)) +#define DRM_FORMAT_ABGR8888 GN_FOURCC('A', 'B', '2', '4') +#define DRM_FORMAT_ARGB8888 GN_FOURCC('A', 'R', '2', '4') + +typedef int32_t (*unixlib_entry_t)(void *); + +enum gn_transport_kind { + GN_TRANSPORT_UNKNOWN = 0, + GN_TRANSPORT_AHARDWAREBUFFER = 1, + GN_TRANSPORT_DMABUF = 2 +}; + +struct gn_transport_image { + VkImage image; + VkDeviceMemory memory; + VkCommandBuffer command_buffer; + void *hardware_buffer; + uint8_t registered; + uint8_t initialized; + uint8_t steady_recorded; +}; + +struct wine_client_object { + uint64_t loader_magic; + uint64_t unix_handle; +}; + +struct gn_image { + VkImage image; + VkDeviceMemory memory; + int dma_buf_fd; + uint32_t plane_count; + uint32_t strides[4]; + uint32_t offsets[4]; + uint64_t modifier; + uint8_t registered_eye_mask; + uint32_t registered_array_index[2]; + uint8_t transport_kind[2]; + struct gn_transport_image transport[2]; + uint8_t submitted; +}; + +struct gn_swapchain { + uint8_t allocated; + uint32_t width; + uint32_t height; + VkFormat format; + uint32_t array_size; + uint32_t sample_count; + uint32_t image_count; + struct gn_image images[GN_UNIX_MAX_IMAGES]; +}; + +static pthread_mutex_t state_mutex = PTHREAD_MUTEX_INITIALIZER; +static pthread_mutex_t socket_mutex = PTHREAD_MUTEX_INITIALIZER; +static struct gn_swapchain swapchains[GN_UNIX_MAX_SWAPCHAINS]; +static VkPhysicalDevice physical_device; +static VkDevice device; +static VkQueue queue; +static uint32_t queue_family_index; +static VkCommandPool command_pool; +static void *vulkan_so; +static int transport_fd = -1; +static uint8_t transport_frame_announced[2]; +static uint64_t transport_frame_id; + +static PFN_vkGetDeviceProcAddr p_vkGetDeviceProcAddr; +static PFN_vkGetPhysicalDeviceMemoryProperties p_vkGetPhysicalDeviceMemoryProperties; +static PFN_vkGetPhysicalDeviceFormatProperties2 p_vkGetPhysicalDeviceFormatProperties2; +static PFN_vkCreateImage p_vkCreateImage; +static PFN_vkDestroyImage p_vkDestroyImage; +static PFN_vkGetImageMemoryRequirements p_vkGetImageMemoryRequirements; +static PFN_vkAllocateMemory p_vkAllocateMemory; +static PFN_vkFreeMemory p_vkFreeMemory; +static PFN_vkBindImageMemory p_vkBindImageMemory; +static PFN_vkGetImageSubresourceLayout p_vkGetImageSubresourceLayout; +static PFN_vkGetImageDrmFormatModifierPropertiesEXT p_vkGetImageDrmFormatModifierPropertiesEXT; +static PFN_vkGetMemoryFdKHR p_vkGetMemoryFdKHR; +static PFN_vkCreateFence p_vkCreateFence; +static PFN_vkDestroyFence p_vkDestroyFence; +static PFN_vkGetFenceFdKHR p_vkGetFenceFdKHR; +static PFN_vkQueueSubmit p_vkQueueSubmit; +static PFN_vkQueueWaitIdle p_vkQueueWaitIdle; +static PFN_vkCreateCommandPool p_vkCreateCommandPool; +static PFN_vkDestroyCommandPool p_vkDestroyCommandPool; +static PFN_vkAllocateCommandBuffers p_vkAllocateCommandBuffers; +static PFN_vkFreeCommandBuffers p_vkFreeCommandBuffers; +static PFN_vkResetCommandBuffer p_vkResetCommandBuffer; +static PFN_vkBeginCommandBuffer p_vkBeginCommandBuffer; +static PFN_vkEndCommandBuffer p_vkEndCommandBuffer; +static PFN_vkCmdPipelineBarrier p_vkCmdPipelineBarrier; +static PFN_vkCmdCopyImage p_vkCmdCopyImage; +#if defined(__ANDROID__) +static PFN_vkGetAndroidHardwareBufferPropertiesANDROID + p_vkGetAndroidHardwareBufferPropertiesANDROID; +#endif + +static void log_line(const char *line) +{ + const char *path = getenv("GAMENATIVE_XR_UNIX_LOG"); + if (!path || !*path) path = "/tmp/gamenative-xr-unix.log"; + FILE *f = fopen(path, "a"); + if (!f) return; + fprintf(f, "%s\n", line); + fclose(f); +} + +static void log_vulkan_context_state(void) +{ + char line[384]; + snprintf(line, sizeof(line), + "Vulkan context phys=%p device=%p queue=%p gpa=%p createImage=%p " + "getMemoryFd=%p createFence=%p getFenceFd=%p queueSubmit=%p " + "commandPool=%p ahb=%p", + (void *)physical_device, (void *)device, (void *)queue, + (void *)p_vkGetDeviceProcAddr, (void *)p_vkCreateImage, + (void *)p_vkGetMemoryFdKHR, (void *)p_vkCreateFence, + (void *)p_vkGetFenceFdKHR, (void *)p_vkQueueSubmit, + (void *)command_pool, +#if defined(__ANDROID__) + (void *)p_vkGetAndroidHardwareBufferPropertiesANDROID +#else + NULL +#endif + ); + log_line(line); +} + +static uintptr_t mapping_lookup_address(uintptr_t address) +{ +#if UINTPTR_MAX > 0xffffffffu + + + + return address & (uintptr_t)0x00ffffffffffffffULL; +#else + return address; +#endif +} + +static uintptr_t readable_mapping_end(uintptr_t address) +{ + address = mapping_lookup_address(address); + FILE *maps = fopen("/proc/self/maps", "r"); + char line[256]; + if (!maps) return address; + while (fgets(line, sizeof(line), maps)) { + unsigned long long start, end; + char permissions[5] = {0}; + if (sscanf(line, "%llx-%llx %4s", &start, &end, permissions) == 3 && + address >= (uintptr_t)start && address < (uintptr_t)end && + permissions[0] == 'r') { + fclose(maps); + return (uintptr_t)end; + } + } + fclose(maps); + return address; +} + +static int readable_mapping_contains(uintptr_t address, size_t size) +{ + uintptr_t lookup_address; + uintptr_t end; + if (!address || !size) return 0; + lookup_address = mapping_lookup_address(address); + end = readable_mapping_end(lookup_address); + return end > lookup_address && size <= end - lookup_address; +} + +static uint64_t unwrap_dispatchable(uint64_t client_handle) +{ + char trace[224]; + const struct wine_client_object *client = + (const struct wine_client_object *)(uintptr_t)client_handle; + if (!readable_mapping_contains((uintptr_t)client, sizeof(*client))) { + snprintf(trace, sizeof(trace), + "unwrap client=0x%llx is not a readable Wine object", + (unsigned long long)client_handle); + log_line(trace); + return 0; + } + if (!client->unix_handle) { + snprintf(trace, sizeof(trace), "unwrap client=0x%llx has no unix object", + (unsigned long long)client_handle); + log_line(trace); + return 0; + } + const uint64_t *object = + (const uint64_t *)(uintptr_t)client->unix_handle; + if (!readable_mapping_contains((uintptr_t)object, 2 * sizeof(*object))) { + snprintf(trace, sizeof(trace), + "unwrap client=0x%llx unix object=0x%llx is not readable", + (unsigned long long)client_handle, + (unsigned long long)client->unix_handle); + log_line(trace); + return 0; + } + if (object[1] == client_handle) { + snprintf(trace, sizeof(trace), + "unwrap client=0x%llx object=0x%llx Wine10+ host=0x%llx", + (unsigned long long)client_handle, + (unsigned long long)client->unix_handle, + (unsigned long long)object[0]); + log_line(trace); + return object[0]; + } + + + + + uintptr_t object_address = mapping_lookup_address((uintptr_t)object); + uintptr_t end = readable_mapping_end(object_address); + size_t words = end > object_address ? + (end - object_address) / sizeof(*object) : 0; + if (words > 8192) words = 8192; + for (size_t i = 0; i + 1 < words; ++i) { + if (object[i] == client_handle) { + snprintf(trace, sizeof(trace), + "unwrap client=0x%llx object=0x%llx Wine9 index=%zu host=0x%llx", + (unsigned long long)client_handle, + (unsigned long long)client->unix_handle, i, + (unsigned long long)object[i + 1]); + log_line(trace); + return object[i + 1]; + } + } + + + + const size_t wine_92_device_host_index = (4088 / sizeof(*object)) + 1; + if (words > wine_92_device_host_index && + object[wine_92_device_host_index - 2] && + object[wine_92_device_host_index]) { + snprintf(trace, sizeof(trace), + "unwrap client=0x%llx object=0x%llx Wine9.2 device host=0x%llx", + (unsigned long long)client_handle, + (unsigned long long)client->unix_handle, + (unsigned long long)object[wine_92_device_host_index]); + log_line(trace); + return object[wine_92_device_host_index]; + } + snprintf(trace, sizeof(trace), + "unwrap client=0x%llx object=0x%llx no match words=%zu " + "w510=0x%llx w511=0x%llx w512=0x%llx w513=0x%llx", + (unsigned long long)client_handle, + (unsigned long long)client->unix_handle, words, + (unsigned long long)(words > 510 ? object[510] : 0), + (unsigned long long)(words > 511 ? object[511] : 0), + (unsigned long long)(words > 512 ? object[512] : 0), + (unsigned long long)(words > 513 ? object[513] : 0)); + log_line(trace); + return words ? object[0] : 0; +} + +static int write_all(int fd, const void *data, size_t len) +{ + const char *p = data; + while (len) { + ssize_t n = send(fd, p, len, MSG_NOSIGNAL); + if (n < 0 && errno == EINTR) continue; + if (n <= 0) return 0; + p += n; + len -= (size_t)n; + } + return 1; +} + +static int read_line(int fd, char *line, size_t capacity) +{ + size_t used = 0; + if (!capacity) return 0; + while (used + 1 < capacity) { + char ch; + ssize_t n = recv(fd, &ch, 1, 0); + if (n < 0 && errno == EINTR) continue; + if (n <= 0) return 0; + if (ch == '\n') { + line[used] = 0; + return 1; + } + line[used++] = ch; + } + line[capacity - 1] = 0; + return 0; +} + +static int send_fd(int socket_fd, int fd) +{ + char payload = 'F'; + struct iovec iov = {&payload, 1}; + char control[CMSG_SPACE(sizeof(int))] = {0}; + struct msghdr msg = {0}; + msg.msg_iov = &iov; + msg.msg_iovlen = 1; + msg.msg_control = control; + msg.msg_controllen = sizeof(control); + struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msg); + cmsg->cmsg_level = SOL_SOCKET; + cmsg->cmsg_type = SCM_RIGHTS; + cmsg->cmsg_len = CMSG_LEN(sizeof(int)); + memcpy(CMSG_DATA(cmsg), &fd, sizeof(fd)); + ssize_t n; + do n = sendmsg(socket_fd, &msg, MSG_NOSIGNAL); while (n < 0 && errno == EINTR); + return n == 1; +} + +static int recv_fd(int socket_fd) +{ + char payload; + struct iovec iov = {&payload, 1}; + char control[CMSG_SPACE(sizeof(int))] = {0}; + struct msghdr msg = {0}; + msg.msg_iov = &iov; + msg.msg_iovlen = 1; + msg.msg_control = control; + msg.msg_controllen = sizeof(control); + ssize_t n; + do n = recvmsg(socket_fd, &msg, 0); while (n < 0 && errno == EINTR); + if (n <= 0) return -1; + for (struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msg); cmsg; + cmsg = CMSG_NXTHDR(&msg, cmsg)) { + if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS && + cmsg->cmsg_len == CMSG_LEN(sizeof(int))) { + int fd; + memcpy(&fd, CMSG_DATA(cmsg), sizeof(fd)); + return fd; + } + } + return -1; +} + +static void close_transport(void) +{ + if (transport_fd >= 0) close(transport_fd); + transport_fd = -1; +} + +static int ensure_transport(void) +{ + if (transport_fd >= 0) return 1; + const char *path = getenv("GAMENATIVE_XR_SOCKET"); + if (!path || !*path) path = "@gamenative-xr"; + + int fd = socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0); + if (fd < 0) return 0; + struct sockaddr_un address; + memset(&address, 0, sizeof(address)); + address.sun_family = AF_UNIX; + socklen_t length; + if (path[0] == '@') { + size_t size = strlen(path + 1); + if (size > sizeof(address.sun_path) - 2) size = sizeof(address.sun_path) - 2; + address.sun_path[0] = 0; + memcpy(address.sun_path + 1, path + 1, size); + length = (socklen_t)(offsetof(struct sockaddr_un, sun_path) + 1 + size); + } else { + strncpy(address.sun_path, path, sizeof(address.sun_path) - 1); + length = sizeof(address); + } + if (connect(fd, (struct sockaddr *)&address, length) < 0) { + close(fd); + return 0; + } + if (!write_all(fd, "HELLO producer=wine-unixlib version=2\n", 38)) { + close(fd); + return 0; + } + char response[64]; + if (!read_line(fd, response, sizeof(response)) || strncmp(response, "OK", 2)) { + close(fd); + return 0; + } + transport_fd = fd; + return 1; +} + +static int transact_line(const char *line, char *response, size_t response_size) +{ + if (!ensure_transport() || !write_all(transport_fd, line, strlen(line)) || + !read_line(transport_fd, response, response_size)) { + close_transport(); + return 0; + } + return 1; +} + +static void load_vulkan_functions(void) +{ + if (!vulkan_so) vulkan_so = dlopen("libvulkan.so.1", RTLD_NOW | RTLD_LOCAL); + if (!vulkan_so) return; + p_vkGetDeviceProcAddr = dlsym(vulkan_so, "vkGetDeviceProcAddr"); + p_vkGetPhysicalDeviceMemoryProperties = + dlsym(vulkan_so, "vkGetPhysicalDeviceMemoryProperties"); + p_vkGetPhysicalDeviceFormatProperties2 = + dlsym(vulkan_so, "vkGetPhysicalDeviceFormatProperties2"); + if (!p_vkGetDeviceProcAddr || !device) return; +#define LOAD_DEVICE(name) p_##name = (PFN_##name)p_vkGetDeviceProcAddr(device, #name) + LOAD_DEVICE(vkCreateImage); + LOAD_DEVICE(vkDestroyImage); + LOAD_DEVICE(vkGetImageMemoryRequirements); + LOAD_DEVICE(vkAllocateMemory); + LOAD_DEVICE(vkFreeMemory); + LOAD_DEVICE(vkBindImageMemory); + LOAD_DEVICE(vkGetImageSubresourceLayout); + LOAD_DEVICE(vkGetImageDrmFormatModifierPropertiesEXT); + LOAD_DEVICE(vkGetMemoryFdKHR); + LOAD_DEVICE(vkCreateFence); + LOAD_DEVICE(vkDestroyFence); + LOAD_DEVICE(vkGetFenceFdKHR); + LOAD_DEVICE(vkQueueSubmit); + LOAD_DEVICE(vkQueueWaitIdle); + LOAD_DEVICE(vkCreateCommandPool); + LOAD_DEVICE(vkDestroyCommandPool); + LOAD_DEVICE(vkAllocateCommandBuffers); + LOAD_DEVICE(vkFreeCommandBuffers); + LOAD_DEVICE(vkResetCommandBuffer); + LOAD_DEVICE(vkBeginCommandBuffer); + LOAD_DEVICE(vkEndCommandBuffer); + LOAD_DEVICE(vkCmdPipelineBarrier); + LOAD_DEVICE(vkCmdCopyImage); +#if defined(__ANDROID__) + LOAD_DEVICE(vkGetAndroidHardwareBufferPropertiesANDROID); +#endif +#undef LOAD_DEVICE + + + +#define LOAD_HOST_TRAMPOLINE(name) \ + if (!p_##name) p_##name = (PFN_##name)dlsym(vulkan_so, #name) + LOAD_HOST_TRAMPOLINE(vkGetImageDrmFormatModifierPropertiesEXT); + LOAD_HOST_TRAMPOLINE(vkGetMemoryFdKHR); + LOAD_HOST_TRAMPOLINE(vkGetFenceFdKHR); +#if defined(__ANDROID__) + LOAD_HOST_TRAMPOLINE(vkGetAndroidHardwareBufferPropertiesANDROID); +#endif +#undef LOAD_HOST_TRAMPOLINE +} + +static int find_memory_type(uint32_t bits, VkMemoryPropertyFlags desired) +{ + VkPhysicalDeviceMemoryProperties props; + p_vkGetPhysicalDeviceMemoryProperties(physical_device, &props); + for (uint32_t i = 0; i < props.memoryTypeCount; ++i) { + if ((bits & (1u << i)) && + (props.memoryTypes[i].propertyFlags & desired) == desired) return (int)i; + } + for (uint32_t i = 0; i < props.memoryTypeCount; ++i) + if (bits & (1u << i)) return (int)i; + return -1; +} + +static uint32_t format_to_fourcc(VkFormat format) +{ + switch (format) { + case VK_FORMAT_R8G8B8A8_UNORM: + case VK_FORMAT_R8G8B8A8_SRGB: + return DRM_FORMAT_ABGR8888; + case VK_FORMAT_B8G8R8A8_UNORM: + case VK_FORMAT_B8G8R8A8_SRGB: + return DRM_FORMAT_ARGB8888; + default: + return 0; + } +} + +static void log_vk_result(const char *operation, VkResult result) +{ + char line[160]; + snprintf(line, sizeof(line), "%s failed with VkResult %d", operation, result); + log_line(line); +} + +static int create_image(struct gn_swapchain *swapchain, struct gn_image *out, + uint32_t array_size, uint32_t mip_count, uint32_t sample_count) +{ + VkExternalMemoryImageCreateInfo external = { + .sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, + .handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT + }; + VkImageCreateInfo info = { + .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, + .pNext = &external, + .imageType = VK_IMAGE_TYPE_2D, + .format = swapchain->format, + .extent = {swapchain->width, swapchain->height, 1}, + .mipLevels = mip_count ? mip_count : 1, + .arrayLayers = array_size ? array_size : 1, + .samples = sample_count == 2 ? VK_SAMPLE_COUNT_2_BIT : + sample_count == 4 ? VK_SAMPLE_COUNT_4_BIT : + sample_count == 8 ? VK_SAMPLE_COUNT_8_BIT : VK_SAMPLE_COUNT_1_BIT, + .tiling = VK_IMAGE_TILING_LINEAR, + .usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | + VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT, + .sharingMode = VK_SHARING_MODE_EXCLUSIVE, + .initialLayout = VK_IMAGE_LAYOUT_UNDEFINED + }; + + VkDrmFormatModifierPropertiesListEXT modifier_list = { + .sType = VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT + }; + VkFormatProperties2 format_props = { + .sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2, + .pNext = &modifier_list + }; + VkDrmFormatModifierPropertiesEXT *modifiers = NULL; + VkImageDrmFormatModifierListCreateInfoEXT modifier_info = { + .sType = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT + }; + uint64_t chosen_modifier = 0; + uint32_t chosen_plane_count = 1; + int has_chosen_modifier = 0; + if (p_vkGetPhysicalDeviceFormatProperties2) { + p_vkGetPhysicalDeviceFormatProperties2(physical_device, swapchain->format, &format_props); + if (modifier_list.drmFormatModifierCount) { + modifiers = calloc(modifier_list.drmFormatModifierCount, sizeof(*modifiers)); + modifier_list.pDrmFormatModifierProperties = modifiers; + p_vkGetPhysicalDeviceFormatProperties2(physical_device, swapchain->format, &format_props); + for (uint32_t i = 0; i < modifier_list.drmFormatModifierCount; ++i) { + VkFormatFeatureFlags features = modifiers[i].drmFormatModifierTilingFeatures; + if ((features & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT) && + (features & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) && + modifiers[i].drmFormatModifierPlaneCount >= 1 && + modifiers[i].drmFormatModifierPlaneCount <= 4) { + + + + if (!has_chosen_modifier || modifiers[i].drmFormatModifier == 0) { + chosen_modifier = modifiers[i].drmFormatModifier; + chosen_plane_count = + modifiers[i].drmFormatModifierPlaneCount; + has_chosen_modifier = 1; + } + if (modifiers[i].drmFormatModifier == 0) break; + } + } + } + } + if (has_chosen_modifier) { + modifier_info.drmFormatModifierCount = 1; + modifier_info.pDrmFormatModifiers = &chosen_modifier; + external.pNext = &modifier_info; + info.tiling = VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT; + } + + VkResult result = p_vkCreateImage(device, &info, NULL, &out->image); + free(modifiers); + if (result != VK_SUCCESS && has_chosen_modifier) { + chosen_modifier = 0; + chosen_plane_count = 1; + has_chosen_modifier = 0; + external.pNext = NULL; + info.tiling = VK_IMAGE_TILING_LINEAR; + result = p_vkCreateImage(device, &info, NULL, &out->image); + } + if (result != VK_SUCCESS) { + log_vk_result("vkCreateImage(dma-buf)", result); + goto fail; + } + + VkMemoryRequirements requirements; + p_vkGetImageMemoryRequirements(device, out->image, &requirements); + + + + int memory_type = find_memory_type( + requirements.memoryTypeBits, + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT); + if (memory_type < 0) { + log_line("No compatible memory type for dma-buf image"); + goto fail; + } + + VkMemoryDedicatedAllocateInfo dedicated = { + .sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, + .image = out->image + }; + VkExportMemoryAllocateInfo export_info = { + .sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO, + .pNext = &dedicated, + .handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT + }; + VkMemoryAllocateInfo allocate_info = { + .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, + .pNext = &export_info, + .allocationSize = requirements.size, + .memoryTypeIndex = (uint32_t)memory_type + }; + result = p_vkAllocateMemory(device, &allocate_info, NULL, &out->memory); + if (result != VK_SUCCESS) { + log_vk_result("vkAllocateMemory(dma-buf)", result); + goto fail; + } + result = p_vkBindImageMemory(device, out->image, out->memory, 0); + if (result != VK_SUCCESS) { + log_vk_result("vkBindImageMemory(dma-buf)", result); + goto fail; + } + + VkMemoryGetFdInfoKHR fd_info = { + .sType = VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR, + .memory = out->memory, + .handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT + }; + if (!p_vkGetMemoryFdKHR) { + log_line("vkGetMemoryFdKHR is unavailable"); + goto fail; + } + result = p_vkGetMemoryFdKHR(device, &fd_info, &out->dma_buf_fd); + if (result != VK_SUCCESS) { + log_vk_result("vkGetMemoryFdKHR(dma-buf)", result); + goto fail; + } + + out->plane_count = chosen_plane_count; + for (uint32_t plane = 0; plane < out->plane_count; ++plane) { + VkImageSubresource subresource = { + .aspectMask = out->plane_count == 1 + ? VK_IMAGE_ASPECT_COLOR_BIT + : (VkImageAspectFlags) + (VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT << plane), + .mipLevel = 0, + .arrayLayer = 0 + }; + VkSubresourceLayout layout; + p_vkGetImageSubresourceLayout( + device, out->image, &subresource, &layout); + out->strides[plane] = (uint32_t)layout.rowPitch; + out->offsets[plane] = (uint32_t)layout.offset; + } + out->modifier = has_chosen_modifier ? chosen_modifier : 0; + if (has_chosen_modifier && p_vkGetImageDrmFormatModifierPropertiesEXT) { + VkImageDrmFormatModifierPropertiesEXT props = { + .sType = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT + }; + if (p_vkGetImageDrmFormatModifierPropertiesEXT(device, out->image, &props) == VK_SUCCESS) + out->modifier = props.drmFormatModifier; + } + { + char trace[320]; + snprintf(trace, sizeof(trace), + "dma-buf image format=%d size=%ux%u layers=%u tiling=%s " + "modifier=0x%llx planes=%u stride0=%u offset0=%u", + (int)swapchain->format, swapchain->width, swapchain->height, + array_size ? array_size : 1, + has_chosen_modifier ? "modifier" : "linear", + (unsigned long long)out->modifier, out->plane_count, + out->strides[0], out->offsets[0]); + log_line(trace); + } + return 1; + +fail: + if (out->dma_buf_fd >= 0) close(out->dma_buf_fd); + out->dma_buf_fd = -1; + if (out->memory && p_vkFreeMemory) p_vkFreeMemory(device, out->memory, NULL); + out->memory = VK_NULL_HANDLE; + if (out->image && p_vkDestroyImage) p_vkDestroyImage(device, out->image, NULL); + out->image = VK_NULL_HANDLE; + return 0; +} + +static void destroy_transport_image(struct gn_transport_image *transport) +{ + if (transport->command_buffer && command_pool && p_vkFreeCommandBuffers) + p_vkFreeCommandBuffers(device, command_pool, 1, &transport->command_buffer); + if (transport->image && p_vkDestroyImage) + p_vkDestroyImage(device, transport->image, NULL); + if (transport->memory && p_vkFreeMemory) + p_vkFreeMemory(device, transport->memory, NULL); +#if defined(__ANDROID__) + if (transport->hardware_buffer) + AHardwareBuffer_release((AHardwareBuffer *)transport->hardware_buffer); +#endif + memset(transport, 0, sizeof(*transport)); +} + +#if defined(__ANDROID__) +static int create_ahardwarebuffer_transport( + const struct gn_swapchain *swapchain, struct gn_transport_image *transport) +{ + if (!p_vkGetAndroidHardwareBufferPropertiesANDROID || !command_pool || + !p_vkAllocateCommandBuffers || !p_vkResetCommandBuffer || + !p_vkBeginCommandBuffer || !p_vkEndCommandBuffer || + !p_vkCmdPipelineBarrier || !p_vkCmdCopyImage || !p_vkQueueSubmit) + return 0; + + AHardwareBuffer_Desc descriptor = { + .width = swapchain->width, + .height = swapchain->height, + .layers = 1, + .format = AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM, + .usage = AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE | + AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT + }; + AHardwareBuffer *buffer = NULL; + if (AHardwareBuffer_allocate(&descriptor, &buffer) != 0 || !buffer) { + log_line("AHardwareBuffer allocation unavailable; using dma-buf fallback"); + return 0; + } + transport->hardware_buffer = buffer; + + VkAndroidHardwareBufferFormatPropertiesANDROID format_properties = { + .sType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID + }; + VkAndroidHardwareBufferPropertiesANDROID properties = { + .sType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID, + .pNext = &format_properties + }; + VkResult result = p_vkGetAndroidHardwareBufferPropertiesANDROID( + device, buffer, &properties); + if (result != VK_SUCCESS) { + log_vk_result("vkGetAndroidHardwareBufferPropertiesANDROID", result); + goto fail; + } + if (format_properties.format != VK_FORMAT_R8G8B8A8_UNORM) { + char trace[160]; + snprintf(trace, sizeof(trace), + "AHardwareBuffer returned unsupported Vulkan format=%d", + (int)format_properties.format); + log_line(trace); + goto fail; + } + + VkExternalMemoryImageCreateInfo external = { + .sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, + .handleTypes = + VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID + }; + VkImageCreateInfo image_info = { + .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, + .pNext = &external, + .imageType = VK_IMAGE_TYPE_2D, + .format = VK_FORMAT_R8G8B8A8_UNORM, + .extent = {swapchain->width, swapchain->height, 1}, + .mipLevels = 1, + .arrayLayers = 1, + .samples = VK_SAMPLE_COUNT_1_BIT, + .tiling = VK_IMAGE_TILING_OPTIMAL, + .usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT, + .sharingMode = VK_SHARING_MODE_EXCLUSIVE, + .initialLayout = VK_IMAGE_LAYOUT_UNDEFINED + }; + result = p_vkCreateImage(device, &image_info, NULL, &transport->image); + if (result != VK_SUCCESS) { + log_vk_result("vkCreateImage(AHardwareBuffer)", result); + goto fail; + } + + VkMemoryRequirements requirements; + p_vkGetImageMemoryRequirements(device, transport->image, &requirements); + const uint32_t compatible_types = + requirements.memoryTypeBits & properties.memoryTypeBits; + int memory_type = find_memory_type(compatible_types, 0); + if (memory_type < 0) { + log_line("No compatible memory type for AHardwareBuffer image"); + goto fail; + } + VkImportAndroidHardwareBufferInfoANDROID import_info = { + .sType = VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID, + .buffer = buffer + }; + VkMemoryDedicatedAllocateInfo dedicated = { + .sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, + .pNext = &import_info, + .image = transport->image + }; + VkMemoryAllocateInfo allocate_info = { + .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, + .pNext = &dedicated, + .allocationSize = properties.allocationSize, + .memoryTypeIndex = (uint32_t)memory_type + }; + result = p_vkAllocateMemory( + device, &allocate_info, NULL, &transport->memory); + if (result != VK_SUCCESS) { + log_vk_result("vkAllocateMemory(AHardwareBuffer)", result); + goto fail; + } + result = p_vkBindImageMemory( + device, transport->image, transport->memory, 0); + if (result != VK_SUCCESS) { + log_vk_result("vkBindImageMemory(AHardwareBuffer)", result); + goto fail; + } + + VkCommandBufferAllocateInfo command_info = { + .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, + .commandPool = command_pool, + .level = VK_COMMAND_BUFFER_LEVEL_PRIMARY, + .commandBufferCount = 1 + }; + result = p_vkAllocateCommandBuffers( + device, &command_info, &transport->command_buffer); + if (result != VK_SUCCESS) { + log_vk_result("vkAllocateCommandBuffers(AHardwareBuffer)", result); + goto fail; + } + log_line("AHardwareBuffer Vulkan transport image created"); + return 1; + +fail: + destroy_transport_image(transport); + return 0; +} + +static int record_ahardwarebuffer_copy( + const struct gn_swapchain *swapchain, const struct gn_image *source, + struct gn_transport_image *transport, uint32_t array_index) +{ + + + if (transport->initialized && transport->steady_recorded) return 1; + + VkResult result = p_vkResetCommandBuffer(transport->command_buffer, 0); + if (result != VK_SUCCESS) { + log_vk_result("vkResetCommandBuffer(AHardwareBuffer)", result); + return 0; + } + VkCommandBufferBeginInfo begin = { + .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, + .flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT + }; + result = p_vkBeginCommandBuffer(transport->command_buffer, &begin); + if (result != VK_SUCCESS) { + log_vk_result("vkBeginCommandBuffer(AHardwareBuffer)", result); + return 0; + } + + VkImageMemoryBarrier before[2] = { + { + .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, + .srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | + VK_ACCESS_SHADER_WRITE_BIT, + .dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT, + .oldLayout = VK_IMAGE_LAYOUT_GENERAL, + .newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, + .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, + .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, + .image = source->image, + .subresourceRange = { + VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, array_index, 1 + } + }, + { + .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, + .srcAccessMask = transport->initialized ? VK_ACCESS_MEMORY_READ_BIT : 0, + .dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT, + .oldLayout = transport->initialized ? + VK_IMAGE_LAYOUT_GENERAL : VK_IMAGE_LAYOUT_UNDEFINED, + .newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, + .srcQueueFamilyIndex = transport->initialized ? + VK_QUEUE_FAMILY_EXTERNAL : VK_QUEUE_FAMILY_IGNORED, + .dstQueueFamilyIndex = transport->initialized ? + queue_family_index : VK_QUEUE_FAMILY_IGNORED, + .image = transport->image, + .subresourceRange = { + VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 + } + } + }; + p_vkCmdPipelineBarrier( + transport->command_buffer, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, + VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, NULL, 0, NULL, 2, before); + + VkImageCopy copy = { + .srcSubresource = { + VK_IMAGE_ASPECT_COLOR_BIT, 0, array_index, 1 + }, + .dstSubresource = { + VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1 + }, + .extent = {swapchain->width, swapchain->height, 1} + }; + p_vkCmdCopyImage( + transport->command_buffer, source->image, + VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, transport->image, + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, ©); + + VkImageMemoryBarrier after[2] = { + { + .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, + .srcAccessMask = VK_ACCESS_TRANSFER_READ_BIT, + .dstAccessMask = VK_ACCESS_MEMORY_READ_BIT | + VK_ACCESS_MEMORY_WRITE_BIT, + .oldLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, + .newLayout = VK_IMAGE_LAYOUT_GENERAL, + .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, + .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, + .image = source->image, + .subresourceRange = { + VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, array_index, 1 + } + }, + { + .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, + .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT, + .dstAccessMask = VK_ACCESS_MEMORY_READ_BIT, + .oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, + .newLayout = VK_IMAGE_LAYOUT_GENERAL, + .srcQueueFamilyIndex = queue_family_index, + .dstQueueFamilyIndex = VK_QUEUE_FAMILY_EXTERNAL, + .image = transport->image, + .subresourceRange = { + VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 + } + } + }; + p_vkCmdPipelineBarrier( + transport->command_buffer, VK_PIPELINE_STAGE_TRANSFER_BIT, + VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, 0, NULL, 0, NULL, 2, after); + result = p_vkEndCommandBuffer(transport->command_buffer); + if (result != VK_SUCCESS) { + log_vk_result("vkEndCommandBuffer(AHardwareBuffer)", result); + return 0; + } + if (transport->initialized) transport->steady_recorded = 1; + return 1; +} +#endif + +static void destroy_image(struct gn_image *image) +{ + for (uint32_t eye = 0; eye < 2; ++eye) + destroy_transport_image(&image->transport[eye]); + if (image->dma_buf_fd >= 0) close(image->dma_buf_fd); + if (image->image && p_vkDestroyImage) p_vkDestroyImage(device, image->image, NULL); + if (image->memory && p_vkFreeMemory) p_vkFreeMemory(device, image->memory, NULL); + memset(image, 0, sizeof(*image)); + image->dma_buf_fd = -1; +} + +static int register_ahardwarebuffer( + uint32_t slot, uint32_t image_index, uint32_t eye) +{ +#if defined(__ANDROID__) + struct gn_swapchain *swapchain = &swapchains[slot]; + struct gn_image *image = &swapchain->images[image_index]; + struct gn_transport_image *transport = &image->transport[eye]; + if (swapchain->sample_count != 1) return 0; + if (!transport->hardware_buffer && + !create_ahardwarebuffer_transport(swapchain, transport)) return 0; + if (transport->registered) return 1; + + const uint32_t transport_index = slot * GN_UNIX_MAX_IMAGES + image_index; + const int swap_red_blue = + swapchain->format == VK_FORMAT_B8G8R8A8_UNORM || + swapchain->format == VK_FORMAT_B8G8R8A8_SRGB; + char line[192], response[64] = {0}; + snprintf(line, sizeof(line), + "BUFFER eye=%u index=%u w=%u h=%u swizzle=%u\n", + eye, transport_index, swapchain->width, swapchain->height, + swap_red_blue ? 1u : 0u); + if (!transact_line(line, response, sizeof(response)) || + strncmp(response, "OK", 2) || + AHardwareBuffer_sendHandleToUnixSocket( + (AHardwareBuffer *)transport->hardware_buffer, + transport_fd) != 0 || + !read_line(transport_fd, response, sizeof(response)) || + strncmp(response, "OK", 2)) { + log_line("AHardwareBuffer registration failed; using dma-buf fallback"); + close_transport(); + return 0; + } + transport->registered = 1; + { + char trace[192]; + snprintf(trace, sizeof(trace), + "AHardwareBuffer registered eye=%u index=%u size=%ux%u swizzle=%u", + eye, transport_index, swapchain->width, swapchain->height, + swap_red_blue ? 1u : 0u); + log_line(trace); + } + return 1; +#else + (void)slot; + (void)image_index; + (void)eye; + return 0; +#endif +} + +static int register_image(uint32_t slot, uint32_t image_index, uint32_t eye, + uint32_t array_index) +{ + struct gn_swapchain *swapchain = &swapchains[slot]; + struct gn_image *image = &swapchain->images[image_index]; + const uint8_t bit = (uint8_t)(1u << eye); + if (array_index >= swapchain->array_size) return 0; + if ((image->registered_eye_mask & bit) && + image->registered_array_index[eye] == array_index) return 1; + + if (image->transport_kind[eye] == GN_TRANSPORT_UNKNOWN) { + if (register_ahardwarebuffer(slot, image_index, eye)) { + image->transport_kind[eye] = GN_TRANSPORT_AHARDWAREBUFFER; + image->registered_eye_mask |= bit; + image->registered_array_index[eye] = array_index; + return 1; + } + destroy_transport_image(&image->transport[eye]); + image->transport_kind[eye] = GN_TRANSPORT_DMABUF; + } + if (image->transport_kind[eye] == GN_TRANSPORT_AHARDWAREBUFFER) { + if (image->registered_array_index[eye] != array_index) { + image->transport[eye].steady_recorded = 0; + } + image->registered_array_index[eye] = array_index; + return 1; + } + + VkSubresourceLayout layouts[4]; + for (uint32_t plane = 0; plane < image->plane_count; ++plane) { + VkImageSubresource subresource = { + .aspectMask = image->plane_count == 1 + ? VK_IMAGE_ASPECT_COLOR_BIT + : (VkImageAspectFlags) + (VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT << plane), + .mipLevel = 0, + .arrayLayer = array_index + }; + p_vkGetImageSubresourceLayout( + device, image->image, &subresource, &layouts[plane]); + } + + char line[512], response[64] = {0}; + const uint32_t fourcc = format_to_fourcc(swapchain->format); + if (!fourcc) return 0; + const uint32_t transport_index = slot * GN_UNIX_MAX_IMAGES + image_index; + int length = snprintf( + line, sizeof(line), + "DMABUF eye=%u index=%u w=%u h=%u planes=%u fourcc=0x%08x " + "modifier=0x%llx", + eye, transport_index, swapchain->width, swapchain->height, + image->plane_count, fourcc, (unsigned long long)image->modifier); + for (uint32_t plane = 0; + plane < image->plane_count && length > 0 && + (size_t)length < sizeof(line); ++plane) { + length += snprintf( + line + length, sizeof(line) - (size_t)length, + " stride%u=%u offset%u=%u", + plane, (uint32_t)layouts[plane].rowPitch, + plane, (uint32_t)layouts[plane].offset); + } + if (length <= 0 || (size_t)length + 2 > sizeof(line)) return 0; + line[length++] = '\n'; + line[length] = 0; + int sent_planes = 1; + if (!transact_line(line, response, sizeof(response)) || + strncmp(response, "OK", 2)) { + char trace[192]; + snprintf(trace, sizeof(trace), + "dma-buf registration rejected eye=%u index=%u response=%s", + eye, transport_index, response[0] ? response : ""); + log_line(trace); + sent_planes = 0; + } + for (uint32_t plane = 0; + sent_planes && plane < image->plane_count; ++plane) { + if (!send_fd(transport_fd, image->dma_buf_fd)) sent_planes = 0; + } + if (!sent_planes || + !read_line(transport_fd, response, sizeof(response)) || strncmp(response, "OK", 2)) { + close_transport(); + return 0; + } + image->registered_eye_mask |= bit; + image->registered_array_index[eye] = array_index; + { + char trace[320]; + snprintf(trace, sizeof(trace), + "dma-buf registered eye=%u index=%u array=%u size=%ux%u " + "fourcc=0x%08x modifier=0x%llx planes=%u stride0=%u offset0=%u", + eye, transport_index, array_index, swapchain->width, + swapchain->height, fourcc, + (unsigned long long)image->modifier, image->plane_count, + (uint32_t)layouts[0].rowPitch, (uint32_t)layouts[0].offset); + log_line(trace); + } + return 1; +} + +static int submit_and_make_acquire_fence_fd( + const VkCommandBuffer *commands, uint32_t command_count, int *submit_ok) +{ + *submit_ok = 0; + if (!p_vkQueueSubmit) return -1; + VkSubmitInfo submit = { + .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO, + .commandBufferCount = command_count, + .pCommandBuffers = command_count ? commands : NULL + }; + const int can_export = p_vkCreateFence && p_vkDestroyFence && + p_vkGetFenceFdKHR; + VkFence fence = VK_NULL_HANDLE; + if (!can_export) { + VkResult result = p_vkQueueSubmit(queue, 1, &submit, VK_NULL_HANDLE); + if (result != VK_SUCCESS) { + log_vk_result("vkQueueSubmit(stereo transport)", result); + return -1; + } + if (!p_vkQueueWaitIdle || p_vkQueueWaitIdle(queue) != VK_SUCCESS) + return -1; + *submit_ok = 1; + return -1; + } + VkExportFenceCreateInfo export_info = { + .sType = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO, + .handleTypes = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT + }; + VkFenceCreateInfo create_info = { + .sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, + .pNext = &export_info + }; + if (p_vkCreateFence(device, &create_info, NULL, &fence) != VK_SUCCESS) { + VkResult result = p_vkQueueSubmit(queue, 1, &submit, VK_NULL_HANDLE); + if (result != VK_SUCCESS) { + log_vk_result("vkQueueSubmit(stereo transport fallback)", result); + return -1; + } + if (!p_vkQueueWaitIdle || p_vkQueueWaitIdle(queue) != VK_SUCCESS) + return -1; + *submit_ok = 1; + return -1; + } + if (p_vkQueueSubmit(queue, 1, &submit, fence) != VK_SUCCESS) { + p_vkDestroyFence(device, fence, NULL); + return -1; + } + *submit_ok = 1; + VkFenceGetFdInfoKHR fd_info = { + .sType = VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR, + .fence = fence, + .handleType = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT + }; + int fd = -1; + if (p_vkGetFenceFdKHR(device, &fd_info, &fd) != VK_SUCCESS) fd = -1; + p_vkDestroyFence(device, fence, NULL); + if (fd < 0) { + if (!p_vkQueueWaitIdle || p_vkQueueWaitIdle(queue) != VK_SUCCESS) { + *submit_ok = 0; + return -1; + } + } + return fd; +} + +static int32_t unix_init(void *opaque) +{ + struct gn_unix_init_args *args = opaque; + args->result = args->abi_version == GN_UNIX_ABI_VERSION ? + GN_UNIX_SUCCESS : GN_UNIX_ERROR_ARGUMENT; + log_line("unixlib initialized"); + return 0; +} + +static int32_t unix_set_vulkan_context(void *opaque) +{ + struct gn_unix_vulkan_context_args *args = opaque; + char trace[256]; + pthread_mutex_lock(&state_mutex); + args->diagnostic_flags = 0; + snprintf(trace, sizeof(trace), + "Vulkan context request source=%s phys=0x%llx device=0x%llx queue=0x%llx", + args->handles_are_host ? "host" : "wine-client", + (unsigned long long)args->client_physical_device, + (unsigned long long)args->client_device, + (unsigned long long)args->client_queue); + log_line(trace); + if (args->handles_are_host) { + physical_device = (VkPhysicalDevice)(uintptr_t)args->client_physical_device; + device = (VkDevice)(uintptr_t)args->client_device; + queue = (VkQueue)(uintptr_t)args->client_queue; + } else { + physical_device = (VkPhysicalDevice)(uintptr_t)unwrap_dispatchable(args->client_physical_device); + device = (VkDevice)(uintptr_t)unwrap_dispatchable(args->client_device); + queue = (VkQueue)(uintptr_t)unwrap_dispatchable(args->client_queue); + } + queue_family_index = args->queue_family_index; + if (readable_mapping_contains((uintptr_t)physical_device, sizeof(void *))) + args->diagnostic_flags |= GN_UNIX_VK_DIAG_PHYSICAL_DEVICE; + if (readable_mapping_contains((uintptr_t)device, sizeof(void *))) + args->diagnostic_flags |= GN_UNIX_VK_DIAG_DEVICE; + if (readable_mapping_contains((uintptr_t)queue, sizeof(void *))) + args->diagnostic_flags |= GN_UNIX_VK_DIAG_QUEUE; + if ((args->diagnostic_flags & + (GN_UNIX_VK_DIAG_PHYSICAL_DEVICE | GN_UNIX_VK_DIAG_DEVICE | + GN_UNIX_VK_DIAG_QUEUE)) != + (GN_UNIX_VK_DIAG_PHYSICAL_DEVICE | GN_UNIX_VK_DIAG_DEVICE | + GN_UNIX_VK_DIAG_QUEUE)) { + log_line("Vulkan context rejected: resolved host handles are not readable"); + physical_device = VK_NULL_HANDLE; + device = VK_NULL_HANDLE; + queue = VK_NULL_HANDLE; + args->result = GN_UNIX_ERROR_UNAVAILABLE; + pthread_mutex_unlock(&state_mutex); + return 0; + } + load_vulkan_functions(); +#if defined(__ANDROID__) + if (p_vkGetAndroidHardwareBufferPropertiesANDROID && + p_vkCreateCommandPool && !command_pool) { + VkCommandPoolCreateInfo pool_info = { + .sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, + .flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, + .queueFamilyIndex = queue_family_index + }; + VkResult pool_result = p_vkCreateCommandPool( + device, &pool_info, NULL, &command_pool); + if (pool_result != VK_SUCCESS) { + command_pool = VK_NULL_HANDLE; + log_vk_result("vkCreateCommandPool(AHardwareBuffer)", pool_result); + } + } +#endif + if (vulkan_so) args->diagnostic_flags |= GN_UNIX_VK_DIAG_VULKAN_LIBRARY; + if (p_vkGetDeviceProcAddr) + args->diagnostic_flags |= GN_UNIX_VK_DIAG_GET_DEVICE_PROC_ADDR; + if (p_vkCreateImage) args->diagnostic_flags |= GN_UNIX_VK_DIAG_CREATE_IMAGE; + if (p_vkGetMemoryFdKHR) + args->diagnostic_flags |= GN_UNIX_VK_DIAG_GET_MEMORY_FD; + log_vulkan_context_state(); + args->result = physical_device && device && queue && p_vkCreateImage && + p_vkGetMemoryFdKHR ? GN_UNIX_SUCCESS : GN_UNIX_ERROR_UNAVAILABLE; + pthread_mutex_unlock(&state_mutex); + log_line(args->result ? "Vulkan context unavailable" : "Vulkan context ready"); + return 0; +} + +static int32_t unix_create_swapchain(void *opaque) +{ + struct gn_unix_create_swapchain_args *args = opaque; + if (args->slot >= GN_UNIX_MAX_SWAPCHAINS || !args->width || !args->height || + !device || !format_to_fourcc((VkFormat)args->format)) { + args->result = GN_UNIX_ERROR_ARGUMENT; + return 0; + } + pthread_mutex_lock(&state_mutex); + struct gn_swapchain *swapchain = &swapchains[args->slot]; + if (swapchain->allocated) { + args->result = GN_UNIX_ERROR_ARGUMENT; + pthread_mutex_unlock(&state_mutex); + return 0; + } + memset(swapchain, 0, sizeof(*swapchain)); + swapchain->width = args->width; + swapchain->height = args->height; + swapchain->format = (VkFormat)args->format; + swapchain->array_size = args->array_size ? args->array_size : 1; + swapchain->sample_count = args->sample_count ? args->sample_count : 1; + + + swapchain->image_count = 2; + for (uint32_t i = 0; i < swapchain->image_count; ++i) { + swapchain->images[i].dma_buf_fd = -1; + if (!create_image(swapchain, &swapchain->images[i], args->array_size, + args->mip_count, args->sample_count)) { + for (uint32_t j = 0; j <= i; ++j) destroy_image(&swapchain->images[j]); + memset(swapchain, 0, sizeof(*swapchain)); + args->result = GN_UNIX_ERROR_VULKAN; + pthread_mutex_unlock(&state_mutex); + return 0; + } + args->images[i] = (gn_u64)(uintptr_t)swapchain->images[i].image; + } + swapchain->allocated = 1; + args->image_count = swapchain->image_count; + args->result = GN_UNIX_SUCCESS; + pthread_mutex_unlock(&state_mutex); + log_line("swapchain created"); + return 0; +} + +static int32_t unix_destroy_swapchain(void *opaque) +{ + struct gn_unix_destroy_swapchain_args *args = opaque; + if (args->slot >= GN_UNIX_MAX_SWAPCHAINS) { + args->result = GN_UNIX_ERROR_ARGUMENT; + return 0; + } + pthread_mutex_lock(&state_mutex); + struct gn_swapchain *swapchain = &swapchains[args->slot]; + for (uint32_t i = 0; i < swapchain->image_count; ++i) + destroy_image(&swapchain->images[i]); + memset(swapchain, 0, sizeof(*swapchain)); + args->result = GN_UNIX_SUCCESS; + pthread_mutex_unlock(&state_mutex); + return 0; +} + +static int32_t unix_acquire_image(void *opaque) +{ + struct gn_unix_acquire_image_args *args = opaque; + if (args->slot >= GN_UNIX_MAX_SWAPCHAINS || + args->image_index >= GN_UNIX_MAX_IMAGES) { + args->result = GN_UNIX_ERROR_ARGUMENT; + return 0; + } + pthread_mutex_lock(&socket_mutex); + char line[512], response[64] = {0}; + snprintf(line, sizeof(line), "ACQUIRE eye=0 index=%u\n", args->image_index); + + + struct gn_image *image = &swapchains[args->slot].images[args->image_index]; + int timeout_ms; + if (args->timeout_ns < 0 || args->timeout_ns > 2147483647000000LL) + timeout_ms = -1; + else + timeout_ms = (int)((args->timeout_ns + 999999) / 1000000); + for (uint32_t eye = 0; eye < 2; ++eye) { + if (!(image->registered_eye_mask & (1u << eye))) continue; + const uint32_t transport_index = + args->slot * GN_UNIX_MAX_IMAGES + args->image_index; + snprintf(line, sizeof(line), "ACQUIRE eye=%u index=%u timeout=%d\n", + eye, transport_index, timeout_ms); + if (!transact_line(line, response, sizeof(response))) { + args->result = GN_UNIX_ERROR_TRANSPORT; + pthread_mutex_unlock(&socket_mutex); + return 0; + } + if (!strcmp(response, "ERR timeout")) { + args->result = GN_UNIX_ERROR_TIMEOUT; + pthread_mutex_unlock(&socket_mutex); + return 0; + } + if (strncmp(response, "OK", 2)) { + args->result = GN_UNIX_ERROR_TRANSPORT; + pthread_mutex_unlock(&socket_mutex); + return 0; + } + if (strstr(response, "fence=1")) { + int fd = recv_fd(transport_fd); + if (fd < 0) { + close_transport(); + args->result = GN_UNIX_ERROR_TRANSPORT; + pthread_mutex_unlock(&socket_mutex); + return 0; + } + struct pollfd pfd = {fd, POLLIN, 0}; + int waited; + do waited = poll(&pfd, 1, timeout_ms); while (waited < 0 && errno == EINTR); + close(fd); + if (waited <= 0) { + args->result = waited == 0 ? GN_UNIX_ERROR_TIMEOUT : GN_UNIX_ERROR_TRANSPORT; + pthread_mutex_unlock(&socket_mutex); + return 0; + } + } + } + image->submitted = 0; + args->result = GN_UNIX_SUCCESS; + pthread_mutex_unlock(&socket_mutex); + return 0; +} + +static int send_frame(const struct gn_unix_submit_view_args *view, int fence_fd, + uint64_t frame_id) +{ + char line[512], response[64] = {0}; + const uint32_t transport_index = + view->slot * GN_UNIX_MAX_IMAGES + view->image_index; + snprintf(line, sizeof(line), + "FRAME frame=%llu eye=%u index=%u fence=%u x=%d y=%d w=%u h=%u " + "projection=1 qx=%lld qy=%lld qz=%lld qw=%lld " + "px=%lld py=%lld pz=%lld fl=%lld fr=%lld fu=%lld fd=%lld\n", + (unsigned long long)frame_id, view->eye, transport_index, + fence_fd >= 0 ? 1u : 0u, + view->rect_x, view->rect_y, view->rect_width, view->rect_height, + (long long)view->orientation_micro[0], + (long long)view->orientation_micro[1], + (long long)view->orientation_micro[2], + (long long)view->orientation_micro[3], + (long long)view->position_micro[0], + (long long)view->position_micro[1], + (long long)view->position_micro[2], + (long long)view->fov_micro[0], + (long long)view->fov_micro[1], + (long long)view->fov_micro[2], + (long long)view->fov_micro[3]); + int ok = 0; + if (fence_fd >= 0) { + ok = transact_line(line, response, sizeof(response)) && + !strncmp(response, "OK", 2) && + send_fd(transport_fd, fence_fd) && + read_line(transport_fd, response, sizeof(response)) && + !strncmp(response, "OK", 2); + } else { + ok = transact_line(line, response, sizeof(response)) && + !strncmp(response, "OK", 2); + } + if (!ok) { + char trace[192]; + snprintf(trace, sizeof(trace), + "frame transport failed eye=%u index=%u response=%s", + view->eye, transport_index, response[0] ? response : ""); + log_line(trace); + close_transport(); + } else if (!transport_frame_announced[view->eye]) { + char trace[160]; + snprintf(trace, sizeof(trace), + "first transported frame eye=%u index=%u fence=%u", + view->eye, transport_index, fence_fd >= 0 ? 1u : 0u); + log_line(trace); + transport_frame_announced[view->eye] = 1; + } + swapchains[view->slot].images[view->image_index].submitted = ok ? 1 : 0; + return ok; +} + +static int submit_views( + const struct gn_unix_submit_view_args *views, uint32_t view_count) +{ + if (!view_count || view_count > 2) return 0; + for (uint32_t i = 0; i < view_count; ++i) { + const struct gn_unix_submit_view_args *view = &views[i]; + if (view->slot >= GN_UNIX_MAX_SWAPCHAINS || view->eye >= 2 || + view->image_index >= swapchains[view->slot].image_count) + return 0; + } + + pthread_mutex_lock(&socket_mutex); + VkCommandBuffer commands[2]; + struct gn_transport_image *recorded[2]; + uint32_t command_count = 0; + for (uint32_t i = 0; i < view_count; ++i) { + const struct gn_unix_submit_view_args *view = &views[i]; + if (!register_image(view->slot, view->image_index, view->eye, + view->array_index)) { + pthread_mutex_unlock(&socket_mutex); + return 0; + } +#if defined(__ANDROID__) + struct gn_image *image = + &swapchains[view->slot].images[view->image_index]; + if (image->transport_kind[view->eye] == GN_TRANSPORT_AHARDWAREBUFFER) { + struct gn_transport_image *transport = &image->transport[view->eye]; + if (!record_ahardwarebuffer_copy( + &swapchains[view->slot], image, transport, + view->array_index)) { + const uint8_t bit = (uint8_t)(1u << view->eye); + log_line("AHardwareBuffer GPU copy failed; switching image to dma-buf"); + destroy_transport_image(transport); + image->transport_kind[view->eye] = GN_TRANSPORT_DMABUF; + image->registered_eye_mask &= (uint8_t)~bit; + if (!register_image(view->slot, view->image_index, view->eye, + view->array_index)) { + pthread_mutex_unlock(&socket_mutex); + return 0; + } + } else { + commands[command_count] = transport->command_buffer; + recorded[command_count] = transport; + ++command_count; + } + } +#endif + } + + int submit_ok = 0; + int fence_fd = submit_and_make_acquire_fence_fd( + commands, command_count, &submit_ok); + if (!submit_ok) { + if (fence_fd >= 0) close(fence_fd); + pthread_mutex_unlock(&socket_mutex); + return 0; + } + for (uint32_t i = 0; i < command_count; ++i) recorded[i]->initialized = 1; + + int ok = 1; + const uint64_t frame_id = ++transport_frame_id; + for (uint32_t i = 0; i < view_count; ++i) { + const int view_fence_fd = i == 0 ? fence_fd : -1; + if (!send_frame(&views[i], view_fence_fd, frame_id)) { + ok = 0; + break; + } + } + if (fence_fd >= 0) close(fence_fd); + + pthread_mutex_unlock(&socket_mutex); + return ok; +} + +static int32_t unix_submit_image(void *opaque) +{ + struct gn_unix_submit_image_args *args = opaque; + args->result = submit_views( + (const struct gn_unix_submit_view_args *)args, 1) ? + GN_UNIX_SUCCESS : GN_UNIX_ERROR_TRANSPORT; + return 0; +} + +static int32_t unix_submit_stereo(void *opaque) +{ + struct gn_unix_submit_stereo_args *args = opaque; + if (!args->view_count || args->view_count > 2) { + args->result = GN_UNIX_ERROR_ARGUMENT; + return 0; + } + args->result = submit_views(args->views, args->view_count) ? + GN_UNIX_SUCCESS : GN_UNIX_ERROR_TRANSPORT; + return 0; +} + +__attribute__((visibility("default"))) +const unixlib_entry_t __wine_unix_call_funcs[GN_UNIX_CALL_COUNT] = { + unix_init, + unix_set_vulkan_context, + unix_create_swapchain, + unix_destroy_swapchain, + unix_acquire_image, + unix_submit_image, + unix_submit_stereo +}; + + + +__attribute__((visibility("default"))) +const unixlib_entry_t __wine_unix_call_wow64_funcs[GN_UNIX_CALL_COUNT] = { + unix_init, + unix_set_vulkan_context, + unix_create_swapchain, + unix_destroy_swapchain, + unix_acquire_image, + unix_submit_image, + unix_submit_stereo +}; + +__attribute__((destructor)) +static void unix_shutdown(void) +{ + close_transport(); + for (uint32_t slot = 0; slot < GN_UNIX_MAX_SWAPCHAINS; ++slot) { + if (!swapchains[slot].allocated) continue; + for (uint32_t image = 0; + image < swapchains[slot].image_count; ++image) + destroy_image(&swapchains[slot].images[image]); + } + if (command_pool && p_vkDestroyCommandPool) + p_vkDestroyCommandPool(device, command_pool, NULL); + command_pool = VK_NULL_HANDLE; +} diff --git a/app/src/main/windows/openxr_runtime/ws2_32_x64.def b/app/src/main/windows/openxr_runtime/ws2_32_x64.def new file mode 100644 index 0000000000..6d828209c4 --- /dev/null +++ b/app/src/main/windows/openxr_runtime/ws2_32_x64.def @@ -0,0 +1,10 @@ +LIBRARY WS2_32.dll +EXPORTS + WSAStartup + socket + connect + send + recv + closesocket + htons + inet_addr diff --git a/app/src/main/windows/openxr_runtime/ws2_32_x86.def b/app/src/main/windows/openxr_runtime/ws2_32_x86.def new file mode 100644 index 0000000000..90517dd91b --- /dev/null +++ b/app/src/main/windows/openxr_runtime/ws2_32_x86.def @@ -0,0 +1,10 @@ +LIBRARY WS2_32.dll +EXPORTS + WSAStartup@8 + socket@12 + connect@12 + send@16 + recv@16 + closesocket@4 + htons@4 + inet_addr@4 diff --git a/tools/build-windows-xr-runtime.ps1 b/tools/build-windows-xr-runtime.ps1 new file mode 100644 index 0000000000..d3670b84d5 --- /dev/null +++ b/tools/build-windows-xr-runtime.ps1 @@ -0,0 +1,60 @@ +param( + [string]$Configuration = "Release" +) + +$ErrorActionPreference = "Stop" +$repository = Split-Path -Parent $PSScriptRoot +$source = Join-Path $repository "app\src\main\windows\openxr_runtime" +$build = Join-Path $repository "app\build\windows-xr-runtime" +$output = Join-Path $repository "app\build\generated\xrPayload\modernXr" +$ndk = Join-Path $env:LOCALAPPDATA "Android\Sdk\ndk\29.0.14206865" +$clang = Join-Path $ndk "toolchains\llvm\prebuilt\windows-x86_64\bin\clang.exe" +$dlltool = Join-Path $ndk "toolchains\llvm\prebuilt\windows-x86_64\bin\llvm-dlltool.exe" +if (!(Test-Path $clang) -or !(Test-Path $dlltool)) { throw "Android NDK 29 LLVM tools are required" } +New-Item -ItemType Directory -Force -Path $build, $output | Out-Null +cmake -S $source -B $build -G "Visual Studio 17 2022" -A x64 +if ($LASTEXITCODE -ne 0) { throw "OpenXR SDK preparation failed" } +$include = Join-Path $build "_deps\openxr_sdk-build\include" +if (!(Test-Path (Join-Path $include "openxr\openxr.h"))) { throw "OpenXR SDK headers are unavailable" } + +function Invoke-Tool { + param([scriptblock]$Command, [string]$Name) + & $Command + if ($LASTEXITCODE -ne 0) { throw "$Name failed with exit code $LASTEXITCODE" } +} + +$imports = @{} +foreach ($architecture in @("x64", "x86")) { + $machine = if ($architecture -eq "x64") { "i386:x86-64" } else { "i386" } + foreach ($library in @("ws2_32", "kernel32", "ntdll", "dxgi")) { + $archive = Join-Path $build "lib${library}_${architecture}.a" + $definition = Join-Path $source "${library}_${architecture}.def" + if ($architecture -eq "x86") { + Invoke-Tool { & $dlltool -m $machine -k -d $definition -l $archive } "$library $architecture import library" + } else { + Invoke-Tool { & $dlltool -m $machine -d $definition -l $archive } "$library $architecture import library" + } + $imports["$library-$architecture"] = $archive + } +} + +$runtimeSource = Join-Path $source "gamenative_openxr_runtime.c" +$runtime64 = Join-Path $build "gamenative_openxr_runtime64.dll" +$runtime32 = Join-Path $build "gamenative_openxr_runtime32.dll" +Invoke-Tool { & $clang --target=x86_64-w64-windows-gnu -shared -nostdlib "-Wl,-e,DllMain" -I $include -o $runtime64 $runtimeSource (Join-Path $source "gamenative_openxr_runtime_x64.def") $imports["ws2_32-x64"] $imports["kernel32-x64"] $imports["ntdll-x64"] $imports["dxgi-x64"] } "x64 OpenXR runtime" +Invoke-Tool { & $clang --target=i686-w64-windows-gnu -shared -nostdlib "-Wl,-e,DllMain" -I $include -o $runtime32 $runtimeSource (Join-Path $source "gamenative_openxr_runtime_x86.def") $imports["ws2_32-x86"] $imports["kernel32-x86"] $imports["ntdll-x86"] $imports["dxgi-x86"] } "x86 OpenXR runtime" + +function Assert-Machine { + param([string]$Path, [int]$Expected) + $bytes = [System.IO.File]::ReadAllBytes($Path) + $offset = [BitConverter]::ToInt32($bytes, 0x3c) + $actual = [BitConverter]::ToUInt16($bytes, $offset + 4) + if ($actual -ne $Expected) { throw "Unexpected PE machine for $Path" } +} +Assert-Machine $runtime64 0x8664 +Assert-Machine $runtime32 0x014c +Copy-Item -Force -LiteralPath $runtime64 -Destination (Join-Path $output "gamenative_openxr_runtime64.dll") +Copy-Item -Force -LiteralPath $runtime32 -Destination (Join-Path $output "gamenative_openxr_runtime32.dll") +$hash64 = (Get-FileHash -Algorithm SHA256 -LiteralPath $runtime64).Hash.ToLowerInvariant() +$hash32 = (Get-FileHash -Algorithm SHA256 -LiteralPath $runtime32).Hash.ToLowerInvariant() +Set-Content -NoNewline -LiteralPath (Join-Path $output "payload.version") -Value "3 $hash64 $hash32" diff --git a/tools/build-wine-xr-bridge.sh b/tools/build-wine-xr-bridge.sh new file mode 100644 index 0000000000..5dd4b7c3ef --- /dev/null +++ b/tools/build-wine-xr-bridge.sh @@ -0,0 +1,3 @@ +set -eu +repository="$1" +exec "$repository/tools/provision-build-arm64x-wine-bridge.sh" "$repository" diff --git a/tools/build-xr-native.ps1 b/tools/build-xr-native.ps1 new file mode 100644 index 0000000000..87ac3cc1b5 --- /dev/null +++ b/tools/build-xr-native.ps1 @@ -0,0 +1,37 @@ +param( + [string]$Configuration = "Release" +) + +$ErrorActionPreference = "Stop" +$repository = Split-Path -Parent $PSScriptRoot +$sdkLine = Get-Content -LiteralPath (Join-Path $repository "local.properties") | Where-Object { $_ -like "sdk.dir=*" } | Select-Object -First 1 +if (-not $sdkLine) { throw "sdk.dir is missing from local.properties" } +$sdk = $sdkLine.Substring(8).Replace("\\", "\").Replace("\:", ":") +$ndk = Join-Path $sdk "ndk\27.3.13750724" +$cmake = Join-Path $sdk "cmake\3.22.1\bin\cmake.exe" +$ninja = Join-Path $sdk "cmake\3.22.1\bin\ninja.exe" +$aar = Get-ChildItem (Join-Path $env:USERPROFILE ".gradle\caches\modules-2\files-2.1\org.khronos.openxr\openxr_loader_for_android\1.1.61") -Recurse -Filter "openxr_loader_for_android-1.1.61.aar" | Select-Object -First 1 +if (-not $aar) { throw "OpenXR Android loader 1.1.61 is not available in the Gradle cache" } +$work = Join-Path $repository "app\build\xr-native" +$dependency = Join-Path $work "openxr" +$build = Join-Path $work "build" +$output = Join-Path $repository "app\build\generated\xrNative\modernXr\arm64-v8a" +$unixBuild = Join-Path $repository "app\build\xr-unixlib" +$payloadOutput = Join-Path $repository "app\build\generated\xrPayload\modernXr" +New-Item -ItemType Directory -Force -Path $dependency, $build, $output | Out-Null +if (-not (Test-Path (Join-Path $dependency "prefab"))) { + tar -xf $aar.FullName -C $dependency + if ($LASTEXITCODE -ne 0) { throw "Could not extract the OpenXR Android loader" } +} +$openXrDirectory = Join-Path $dependency "prefab\modules\openxr_loader\libs\android.arm64-v8a\cmake\openxr" +& $cmake -S (Join-Path $repository "app\src\main\cpp\xrimmersive") -B $build -G Ninja "-DCMAKE_MAKE_PROGRAM=$ninja" "-DCMAKE_BUILD_TYPE=$Configuration" "-DCMAKE_TOOLCHAIN_FILE=$ndk\build\cmake\android.toolchain.cmake" -DANDROID_ABI=arm64-v8a -DANDROID_PLATFORM=android-29 "-DOpenXR_DIR=$openXrDirectory" +if ($LASTEXITCODE -ne 0) { throw "OpenXR native configuration failed" } +& $cmake --build $build --config $Configuration +if ($LASTEXITCODE -ne 0) { throw "OpenXR native build failed" } +Copy-Item -Force -LiteralPath (Join-Path $build "libxrimmersive.so") -Destination (Join-Path $output "libxrimmersive.so") +New-Item -ItemType Directory -Force -Path $unixBuild, $payloadOutput | Out-Null +& $cmake -S (Join-Path $repository "app\src\main\windows\openxr_runtime\unix") -B $unixBuild -G Ninja "-DCMAKE_MAKE_PROGRAM=$ninja" "-DCMAKE_BUILD_TYPE=$Configuration" "-DCMAKE_TOOLCHAIN_FILE=$ndk\build\cmake\android.toolchain.cmake" -DANDROID_ABI=arm64-v8a -DANDROID_PLATFORM=android-29 +if ($LASTEXITCODE -ne 0) { throw "Wine unixlib configuration failed" } +& $cmake --build $unixBuild --config $Configuration +if ($LASTEXITCODE -ne 0) { throw "Wine unixlib build failed" } +Copy-Item -Force -LiteralPath (Join-Path $unixBuild "gamenative_xr_unixbridge.so") -Destination (Join-Path $payloadOutput "gamenative_xr_unixbridge.so") diff --git a/tools/provision-build-arm64x-wine-bridge.sh b/tools/provision-build-arm64x-wine-bridge.sh new file mode 100644 index 0000000000..c152aab27a --- /dev/null +++ b/tools/provision-build-arm64x-wine-bridge.sh @@ -0,0 +1,121 @@ +set -eu + +repository="$1" +base="${GAMENATIVE_ARM64X_HOME:-$HOME/gamenative-arm64x}" +wine_commit="77eed5501e077f5f0422d063b171a3a4491f52a6" +llvm_archive="llvm-mingw-20250920-ucrt-ubuntu-22.04-x86_64.tar.xz" +llvm_sha="8dd8c34fc051a50c2fae86015f35057f8aae93fe1e19b34537ef1269a8b4c772" +ndk_archive="android-ndk-r27d-linux.zip" +ndk_sha="601246087a682d1944e1e16dd85bc6e49560fe8b6d61255be2829178c8ed15d9" +downloads="$base/downloads" +toolchains="$base/toolchains" +wine_source="$base/wine-arm64x-source" +wine_tools="$base/wine-arm64x-tools" +wine_build="$base/wine-arm64x-build" +output="$repository/app/build/generated/xrPayload/modernXr" +llvm="$toolchains/llvm-mingw-20250920-ucrt-ubuntu-22.04-x86_64" +ndk="$HOME/Android/Sdk/ndk/27.3.13750724" + +mkdir -p "$downloads" "$toolchains" "$HOME/Android/Sdk/ndk" "$output" +if test ! -f "$downloads/$llvm_archive"; then + wget -q "https://github.com/bylaws/llvm-mingw/releases/download/20250920/$llvm_archive" -O "$downloads/$llvm_archive" +fi +if test ! -f "$downloads/$ndk_archive"; then + wget -q "https://dl.google.com/android/repository/$ndk_archive" -O "$downloads/$ndk_archive" +fi +printf '%s %s\n' "$llvm_sha" "$downloads/$llvm_archive" | sha256sum -c - +printf '%s %s\n' "$ndk_sha" "$downloads/$ndk_archive" | sha256sum -c - +if test ! -x "$llvm/bin/clang"; then + tar -xJf "$downloads/$llvm_archive" -C "$toolchains" +fi +if test ! -x "$ndk/toolchains/llvm/prebuilt/linux-x86_64/bin/aarch64-linux-android28-clang"; then + unzip -q "$downloads/$ndk_archive" -d "$HOME/Android/Sdk/ndk" + mv "$HOME/Android/Sdk/ndk/android-ndk-r27d" "$ndk" +fi +if test ! -d "$wine_source/.git"; then + git clone --filter=blob:none --depth 1 --branch build-p10-20260503-sdk28 https://github.com/GameNative/proton-wine.git "$wine_source" +fi +test "$(git -C "$wine_source" rev-parse HEAD)" = "$wine_commit" +module="$wine_source/dlls/gamenative_xr_unixbridge" +mkdir -p "$module" +cp "$repository/app/src/main/windows/openxr_runtime/builtin/Makefile.in" "$module/Makefile.in" +cp "$repository/app/src/main/windows/openxr_runtime/builtin/gamenative_xr_unixbridge.c" "$module/gamenative_xr_unixbridge.c" +cp "$repository/app/src/main/windows/openxr_runtime/builtin/gamenative_xr_unixbridge.spec" "$module/gamenative_xr_unixbridge.spec" +cp "$repository/app/src/main/windows/openxr_runtime/gamenative_openxr_unix_abi.h" "$module/gamenative_openxr_unix_abi.h" +sed -i 's#"../gamenative_openxr_unix_abi.h"#"gamenative_openxr_unix_abi.h"#' "$module/gamenative_xr_unixbridge.c" +if ! grep -q 'WINE_CONFIG_MAKEFILE(dlls/gamenative_xr_unixbridge)' "$wine_source/configure.ac"; then + sed -i '/WINE_CONFIG_MAKEFILE(dlls\/gameinput)/aWINE_CONFIG_MAKEFILE(dlls/gamenative_xr_unixbridge)' "$wine_source/configure.ac" +fi +if test ! -f "$wine_source/.gamenative-arm64x-autogen"; then + (cd "$wine_source" && ./autogen.sh --aarch64 && touch .gamenative-arm64x-autogen) +fi +if test ! -x "$wine_tools/tools/winebuild/winebuild"; then + mkdir -p "$wine_tools" + (cd "$wine_tools" && "$wine_source/configure" --enable-win64 --without-x --without-alsa --without-capi --without-coreaudio --without-cups --without-dbus --without-ffmpeg --without-fontconfig --without-freetype --without-gcrypt --without-gettext --without-gphoto --without-gnutls --without-gssapi --without-gstreamer --without-inotify --without-krb5 --without-netapi --without-opencl --without-opengl --without-osmesa --without-oss --without-pcap --without-pcsclite --without-piper --without-pulse --without-sane --without-sdl --without-udev --without-unwind --without-usb --without-v4l2 --without-vosk --without-vulkan --without-wayland) + make -C "$wine_tools" -j"$(nproc)" __tooldeps__ nls/all +fi +target_tools="$ndk/toolchains/llvm/prebuilt/linux-x86_64/bin" +mingw_tools="$llvm/bin" +export PATH="$mingw_tools:$PATH" +export CC="$target_tools/aarch64-linux-android28-clang" +export CXX="$target_tools/aarch64-linux-android28-clang++" +export AS="$CC" +export AR="$target_tools/llvm-ar" +export RANLIB="$target_tools/llvm-ranlib" +export STRIP="$target_tools/llvm-strip" +export DLLTOOL="$mingw_tools/llvm-dlltool" +if test ! -f "$wine_build/config.status"; then + mkdir -p "$wine_build" + (cd "$wine_build" && "$wine_source/configure" \ + --enable-archs=arm64ec,aarch64 \ + --host=aarch64-linux-android28 \ + --with-mingw=clang \ + --with-wine-tools="$wine_tools" \ + --enable-win64 \ + --disable-win16 \ + --disable-tests \ + --without-x \ + --without-alsa \ + --without-capi \ + --without-coreaudio \ + --without-cups \ + --without-dbus \ + --without-ffmpeg \ + --without-fontconfig \ + --without-freetype \ + --without-gcrypt \ + --without-gettext \ + --without-gphoto \ + --without-gnutls \ + --without-gssapi \ + --without-gstreamer \ + --without-inotify \ + --without-krb5 \ + --without-netapi \ + --without-opencl \ + --without-opengl \ + --without-osmesa \ + --without-oss \ + --without-pcap \ + --without-pcsclite \ + --without-piper \ + --with-pthread \ + --without-pulse \ + --without-sane \ + --without-sdl \ + --without-udev \ + --without-unwind \ + --without-usb \ + --without-v4l2 \ + --without-vosk \ + --without-vulkan \ + --without-wayland) +else + (cd "$wine_build" && ./config.status) +fi +make -C "$wine_build" -j"$(nproc)" dlls/gamenative_xr_unixbridge/all +artifact="$wine_build/dlls/gamenative_xr_unixbridge/aarch64-windows/gamenative_xr_unixbridge.dll" +test -f "$artifact" +cp "$artifact" "$output/gamenative_xr_unixbridge.dll" +printf '%s\n' "$wine_commit" > "$output/gamenative_xr_unixbridge.wine-commit" +"$llvm/bin/llvm-readobj" --file-headers --coff-load-config "$artifact" diff --git a/tools/stage-opencomposite.ps1 b/tools/stage-opencomposite.ps1 new file mode 100644 index 0000000000..29a7f3cc2a --- /dev/null +++ b/tools/stage-opencomposite.ps1 @@ -0,0 +1,15 @@ +$ErrorActionPreference = "Stop" +$repository = Split-Path -Parent $PSScriptRoot +$payload = Join-Path $repository "app\build\generated\xrPayload\modernXr" +$destination = Join-Path $payload "opencomposite_x64.dll" +$uri = "https://opencomposite.znix.xyz/builds/download_build?artefact_id=5r2yCwgFn_ozJ44c&build_id=49918237&commit=43e551a4506880ab1a71b8b9fec2fd7fbb27372f" +$expected = "2f56d45323f252a2ea7c3047c806f9aca3cab36c3f9f71d1dad05a5008b7731a" +New-Item -ItemType Directory -Force -Path $payload | Out-Null +$temporary = "$destination.download" +Invoke-WebRequest -Uri $uri -OutFile $temporary +$actual = (Get-FileHash -Algorithm SHA256 -LiteralPath $temporary).Hash.ToLowerInvariant() +if ($actual -ne $expected) { throw "OpenComposite checksum mismatch: $actual" } +$bytes = [System.IO.File]::ReadAllBytes($temporary) +$offset = [BitConverter]::ToInt32($bytes, 0x3c) +if ([BitConverter]::ToUInt16($bytes, $offset + 4) -ne 0x8664) { throw "OpenComposite payload is not x64" } +Move-Item -Force -LiteralPath $temporary -Destination $destination diff --git a/tools/stage-wine-xr-bridge.ps1 b/tools/stage-wine-xr-bridge.ps1 new file mode 100644 index 0000000000..dc014233aa --- /dev/null +++ b/tools/stage-wine-xr-bridge.ps1 @@ -0,0 +1,15 @@ +param( + [Parameter(Mandatory = $true)] + [string]$CompanionPath +) + +$ErrorActionPreference = "Stop" +$repository = Split-Path -Parent $PSScriptRoot +$output = Join-Path $repository "app\build\generated\xrPayload\modernXr" +$unixlib = Join-Path $output "gamenative_xr_unixbridge.so" +$companion32 = Join-Path $repository "app\src\main\windows\openxr_runtime\builtin\gamenative_xr_unixbridge32.dll" +if (-not (Test-Path -LiteralPath $companion32 -PathType Leaf)) { throw "Missing x86 Wine XR bridge companion" } +& (Join-Path $PSScriptRoot "verify-arm64x-wine-pair.ps1") -CompanionPath $CompanionPath -UnixlibPath $unixlib | Out-Host +New-Item -ItemType Directory -Force -Path $output | Out-Null +Copy-Item -Force -LiteralPath $CompanionPath -Destination (Join-Path $output "gamenative_xr_unixbridge.dll") +Copy-Item -Force -LiteralPath $companion32 -Destination (Join-Path $output "gamenative_xr_unixbridge32.dll") diff --git a/tools/verify-arm64x-wine-pair.ps1 b/tools/verify-arm64x-wine-pair.ps1 new file mode 100644 index 0000000000..1a8b7c4200 --- /dev/null +++ b/tools/verify-arm64x-wine-pair.ps1 @@ -0,0 +1,115 @@ +param( + [Parameter(Mandatory = $true)] + [string]$CompanionPath, + [Parameter(Mandatory = $true)] + [string]$UnixlibPath +) + +$ErrorActionPreference = "Stop" + +function Read-U16([byte[]]$Bytes, [int64]$Offset) { + if ($Offset -lt 0 -or $Offset + 2 -gt $Bytes.Length) { throw "Truncated binary field" } + [BitConverter]::ToUInt16($Bytes, [int]$Offset) +} + +function Read-U32([byte[]]$Bytes, [int64]$Offset) { + if ($Offset -lt 0 -or $Offset + 4 -gt $Bytes.Length) { throw "Truncated binary field" } + [BitConverter]::ToUInt32($Bytes, [int]$Offset) +} + +function Read-U64([byte[]]$Bytes, [int64]$Offset) { + if ($Offset -lt 0 -or $Offset + 8 -gt $Bytes.Length) { throw "Truncated binary field" } + [BitConverter]::ToUInt64($Bytes, [int]$Offset) +} + +function Find-RvaOffset([byte[]]$Bytes, [int64]$PeOffset, [uint32]$Rva) { + $sectionCount = Read-U16 $Bytes ($PeOffset + 6) + $optionalSize = Read-U16 $Bytes ($PeOffset + 20) + $sectionTable = $PeOffset + 24 + $optionalSize + for ($index = 0; $index -lt $sectionCount; $index++) { + $section = $sectionTable + 40 * $index + $virtualSize = Read-U32 $Bytes ($section + 8) + $virtualAddress = Read-U32 $Bytes ($section + 12) + $rawSize = Read-U32 $Bytes ($section + 16) + $rawOffset = Read-U32 $Bytes ($section + 20) + $mappedSize = [Math]::Max($virtualSize, $rawSize) + if ($Rva -ge $virtualAddress -and $Rva -lt $virtualAddress + $mappedSize) { + $offset = $rawOffset + ($Rva - $virtualAddress) + if ($offset -ge $Bytes.Length) { throw "PE RVA maps outside the image" } + return [int64]$offset + } + } + throw "PE RVA is not mapped by a section" +} + +function Has-Ascii([byte[]]$Bytes, [string]$Value) { + $needle = [System.Text.Encoding]::ASCII.GetBytes($Value) + for ($offset = 0; $offset -le $Bytes.Length - $needle.Length; $offset++) { + $matched = $true + for ($index = 0; $index -lt $needle.Length; $index++) { + if ($Bytes[$offset + $index] -ne $needle[$index]) { + $matched = $false + break + } + } + if ($matched) { return $true } + } + return $false +} + +$companion = [System.IO.File]::ReadAllBytes((Resolve-Path -LiteralPath $CompanionPath)) +if ($companion.Length -lt 512 -or (Read-U16 $companion 0) -ne 0x5a4d) { throw "Wine XR bridge is not a valid PE image" } +$peOffset = Read-U32 $companion 0x3c +if ((Read-U32 $companion $peOffset) -ne 0x00004550) { throw "Wine XR bridge PE signature is invalid" } +$machine = Read-U16 $companion ($peOffset + 4) +if ($machine -ne 0xaa64 -and $machine -ne 0xa64e) { throw "Wine XR bridge physical machine is neither ARM64 nor ARM64X" } +$optionalOffset = $peOffset + 24 +if ((Read-U16 $companion $optionalOffset) -ne 0x20b) { throw "Wine XR bridge is not PE32+" } +$sectionAlignment = Read-U32 $companion ($optionalOffset + 32) +$fileAlignment = Read-U32 $companion ($optionalOffset + 36) +if ($sectionAlignment -ne 65536 -or $fileAlignment -ne 65536) { throw "Wine XR bridge alignment is not 64 KiB" } +if ([System.Text.Encoding]::ASCII.GetString($companion, 64, 16) -ne "Wine builtin DLL") { throw "Wine XR bridge has no Wine builtin signature" } +if (-not (Has-Ascii $companion "gnWineUnixCall")) { throw "Wine XR bridge export is missing" } +$directoryCount = Read-U32 $companion ($optionalOffset + 108) +if ($directoryCount -le 10) { throw "Wine XR bridge has no load configuration directory" } +$loadConfigRva = Read-U32 $companion ($optionalOffset + 112 + 10 * 8) +$loadConfigSize = Read-U32 $companion ($optionalOffset + 116 + 10 * 8) +if ($loadConfigRva -eq 0 -or $loadConfigSize -lt 208) { throw "Wine XR bridge load configuration cannot contain CHPE metadata" } +$loadConfigOffset = Find-RvaOffset $companion $peOffset $loadConfigRva +$imageBase = Read-U64 $companion ($optionalOffset + 24) +$chpePointer = Read-U64 $companion ($loadConfigOffset + 200) +if ($chpePointer -eq 0) { throw "Wine XR bridge has no CHPE metadata pointer" } +$chpeRva = if ($chpePointer -ge $imageBase) { $chpePointer - $imageBase } else { $chpePointer } +$chpeOffset = Find-RvaOffset $companion $peOffset ([uint32]$chpeRva) +$chpeVersion = Read-U32 $companion $chpeOffset +$codeMapRva = Read-U32 $companion ($chpeOffset + 4) +$codeMapCount = Read-U32 $companion ($chpeOffset + 8) +if ($chpeVersion -eq 0 -or $codeMapRva -eq 0 -or $codeMapCount -eq 0 -or $codeMapCount -gt 1048576) { throw "Wine XR bridge CHPE metadata is incomplete" } +$codeMapOffset = Find-RvaOffset $companion $peOffset $codeMapRva +$hasArm64 = $false +$hasArm64Ec = $false +for ($index = 0; $index -lt $codeMapCount; $index++) { + $rangeType = (Read-U32 $companion ($codeMapOffset + 8 * $index)) -band 3 + if ($rangeType -eq 0) { $hasArm64 = $true } + if ($rangeType -eq 1) { $hasArm64Ec = $true } +} +if (-not $hasArm64 -or -not $hasArm64Ec) { throw "Wine XR bridge CHPE code map is not ARM64X hybrid" } + +$unixlib = [System.IO.File]::ReadAllBytes((Resolve-Path -LiteralPath $UnixlibPath)) +if ($unixlib.Length -lt 64 -or $unixlib[0] -ne 0x7f -or $unixlib[1] -ne 0x45 -or $unixlib[2] -ne 0x4c -or + $unixlib[3] -ne 0x46 -or $unixlib[4] -ne 2 -or $unixlib[5] -ne 1 -or (Read-U16 $unixlib 18) -ne 183) { + throw "Wine XR unixlib is not a little-endian aarch64 ELF" +} +if (-not (Has-Ascii $unixlib "__wine_unix_call_funcs") -or -not (Has-Ascii $unixlib "__wine_unix_call_wow64_funcs")) { + throw "Wine XR unixlib dispatch exports are missing" +} + +[PSCustomObject]@{ + PhysicalMachine = ('0x{0:x4}' -f $machine) + ChpeVersion = $chpeVersion + ChpeCodeRanges = $codeMapCount + SectionAlignment = $sectionAlignment + FileAlignment = $fileAlignment + CompanionSha256 = (Get-FileHash -Algorithm SHA256 -LiteralPath $CompanionPath).Hash.ToLowerInvariant() + UnixlibSha256 = (Get-FileHash -Algorithm SHA256 -LiteralPath $UnixlibPath).Hash.ToLowerInvariant() +} diff --git a/tools/verify-xr-payload.ps1 b/tools/verify-xr-payload.ps1 new file mode 100644 index 0000000000..361a4bc83a --- /dev/null +++ b/tools/verify-xr-payload.ps1 @@ -0,0 +1,31 @@ +$ErrorActionPreference = "Stop" +$repository = Split-Path -Parent $PSScriptRoot +$payload = Join-Path $repository "app\build\generated\xrPayload\modernXr" +$runtime64 = Join-Path $payload "gamenative_openxr_runtime64.dll" +$runtime32 = Join-Path $payload "gamenative_openxr_runtime32.dll" +$bridge = Join-Path $payload "gamenative_xr_unixbridge.dll" +$bridge32 = Join-Path $payload "gamenative_xr_unixbridge32.dll" +$unixlib = Join-Path $payload "gamenative_xr_unixbridge.so" +$openComposite = Join-Path $payload "opencomposite_x64.dll" + +foreach ($file in @($runtime64, $runtime32, $bridge, $bridge32, $unixlib, $openComposite)) { + if (-not (Test-Path -LiteralPath $file -PathType Leaf)) { throw "Missing XR payload file: $file" } +} + +function Get-PeMachine([string]$Path) { + $bytes = [System.IO.File]::ReadAllBytes($Path) + if ($bytes.Length -lt 256) { throw "Invalid PE image: $Path" } + $offset = [BitConverter]::ToInt32($bytes, 0x3c) + if ($offset -lt 0x40 -or $offset + 6 -gt $bytes.Length) { throw "Invalid PE header: $Path" } + return [BitConverter]::ToUInt16($bytes, $offset + 4) +} + +if ((Get-PeMachine $runtime64) -ne 0x8664) { throw "Windows OpenXR runtime is not x64" } +if ((Get-PeMachine $runtime32) -ne 0x014c) { throw "Windows OpenXR runtime is not x86" } +if ((Get-PeMachine $bridge32) -ne 0x014c) { throw "Wine OpenXR bridge companion is not x86" } +if ((Get-PeMachine $openComposite) -ne 0x8664) { throw "OpenComposite adapter is not x64" } +& (Join-Path $PSScriptRoot "verify-arm64x-wine-pair.ps1") -CompanionPath $bridge -UnixlibPath $unixlib | Out-Host +$entries = foreach ($file in @($runtime64, $runtime32, $bridge, $bridge32, $unixlib, $openComposite)) { + "$(Split-Path -Leaf $file) $((Get-FileHash -Algorithm SHA256 -LiteralPath $file).Hash.ToLowerInvariant())" +} +Set-Content -LiteralPath (Join-Path $payload "payload.version") -Value ((@("schema 4") + $entries) -join "`n") From c0670302066b7a02b011c32eb2d463cc4ee47919 Mon Sep 17 00:00:00 2001 From: Florian Reintgen <85225228+TheReal-Flo@users.noreply.github.com> Date: Sat, 22 Aug 2026 12:37:34 +0200 Subject: [PATCH 02/46] Improve headset VR launch support --- app/src/legacyXr/AndroidManifest.xml | 3 + app/src/main/cpp/xrimmersive/xr_immersive.cpp | 71 +++++++++++++++++-- .../app/gamenative/ui/model/MainViewModel.kt | 2 +- .../screen/library/appscreen/BaseAppScreen.kt | 3 +- .../ui/screen/xr/ImmersiveXrActivity.kt | 25 +++++-- app/src/modernXr/AndroidManifest.xml | 3 + 6 files changed, 90 insertions(+), 17 deletions(-) diff --git a/app/src/legacyXr/AndroidManifest.xml b/app/src/legacyXr/AndroidManifest.xml index ed1859cfb2..bd4f097b73 100644 --- a/app/src/legacyXr/AndroidManifest.xml +++ b/app/src/legacyXr/AndroidManifest.xml @@ -75,6 +75,9 @@ + diff --git a/app/src/main/cpp/xrimmersive/xr_immersive.cpp b/app/src/main/cpp/xrimmersive/xr_immersive.cpp index 08543c9191..ac37a125c2 100644 --- a/app/src/main/cpp/xrimmersive/xr_immersive.cpp +++ b/app/src/main/cpp/xrimmersive/xr_immersive.cpp @@ -342,6 +342,9 @@ bool XrImmersiveSession::setupInstanceAndSession() { if (threadSettingsExtensionAvailable_) extensions.push_back(XR_KHR_ANDROID_THREAD_SETTINGS_EXTENSION_NAME); refreshRateExtensionAvailable_ = IsInstanceExtensionSupported(XR_FB_DISPLAY_REFRESH_RATE_EXTENSION_NAME); if (refreshRateExtensionAvailable_) extensions.push_back(XR_FB_DISPLAY_REFRESH_RATE_EXTENSION_NAME); + const char *picoControllerExtension = "XR_BD_controller_interaction"; + const bool picoControllerExtensionAvailable = IsInstanceExtensionSupported(picoControllerExtension); + if (picoControllerExtensionAvailable) extensions.push_back(picoControllerExtension); XrInstanceCreateInfoAndroidKHR androidInfo{XR_TYPE_INSTANCE_CREATE_INFO_ANDROID_KHR}; androidInfo.applicationVM = vm_; @@ -354,7 +357,7 @@ bool XrImmersiveSession::setupInstanceAndSession() { createInfo.applicationInfo.applicationVersion = 1; std::strncpy(createInfo.applicationInfo.engineName, "GameNative", XR_MAX_ENGINE_NAME_SIZE - 1); createInfo.applicationInfo.engineVersion = 1; - createInfo.applicationInfo.apiVersion = XR_CURRENT_API_VERSION; + createInfo.applicationInfo.apiVersion = XR_API_VERSION_1_0; createInfo.enabledExtensionCount = static_cast(extensions.size()); createInfo.enabledExtensionNames = extensions.data(); @@ -666,12 +669,47 @@ bool XrImmersiveSession::setupInstanceAndSession() { {hapticAction_, path("/user/hand/right/output/haptic")}, }; - XrInteractionProfileSuggestedBinding suggestedBinding{XR_TYPE_INTERACTION_PROFILE_SUGGESTED_BINDING}; - suggestedBinding.interactionProfile = path("/interaction_profiles/oculus/touch_controller"); - suggestedBinding.countSuggestedBindings = static_cast(bindings.size()); - suggestedBinding.suggestedBindings = bindings.data(); - XrCheck(xrSuggestInteractionProfileBindings(instance_, &suggestedBinding), - "xrSuggestInteractionProfileBindings"); + auto suggestBindings = [this, &path](const char *profile, + const std::vector &profileBindings) { + XrInteractionProfileSuggestedBinding suggestion{XR_TYPE_INTERACTION_PROFILE_SUGGESTED_BINDING}; + suggestion.interactionProfile = path(profile); + suggestion.countSuggestedBindings = static_cast(profileBindings.size()); + suggestion.suggestedBindings = profileBindings.data(); + const XrResult result = xrSuggestInteractionProfileBindings(instance_, &suggestion); + if (XR_SUCCEEDED(result)) { + LOGI("OpenXR controller bindings enabled: %s", profile); + } else { + LOGI("OpenXR controller bindings unavailable: %s result=%d", profile, + static_cast(result)); + } + }; + + suggestBindings("/interaction_profiles/oculus/touch_controller", bindings); + + std::vector picoLegacyBindings = { + {buttonXAction_, path("/user/hand/left/input/x/click")}, + {buttonYAction_, path("/user/hand/left/input/y/click")}, + {buttonAAction_, path("/user/hand/right/input/a/click")}, + {buttonBAction_, path("/user/hand/right/input/b/click")}, + {squeezeLAction_, path("/user/hand/left/input/squeeze/value")}, + {squeezeRAction_, path("/user/hand/right/input/squeeze/value")}, + {triggerLAction_, path("/user/hand/left/input/trigger")}, + {triggerRAction_, path("/user/hand/right/input/trigger")}, + {thumbstickLAction_, path("/user/hand/left/input/thumbstick")}, + {thumbstickRAction_, path("/user/hand/right/input/thumbstick")}, + {thumbstickLClickAction_, path("/user/hand/left/input/thumbstick/click")}, + {thumbstickRClickAction_, path("/user/hand/right/input/thumbstick/click")}, + {menuLAction_, path("/user/hand/left/input/menu/click")}, + {aimPoseLeftAction_, path("/user/hand/left/input/aim/pose")}, + {aimPoseRightAction_, path("/user/hand/right/input/aim/pose")}, + {hapticAction_, path("/user/hand/left/output/haptic")}, + {hapticAction_, path("/user/hand/right/output/haptic")}, + }; + if (picoControllerExtensionAvailable) { + suggestBindings("/interaction_profiles/pico/neo3_controller", picoLegacyBindings); + suggestBindings("/interaction_profiles/bytedance/pico_neo3_controller", bindings); + suggestBindings("/interaction_profiles/bytedance/pico4_controller", bindings); + } XrSessionActionSetsAttachInfo attachInfo{XR_TYPE_SESSION_ACTION_SETS_ATTACH_INFO}; attachInfo.countActionSets = 1; @@ -724,6 +762,25 @@ void XrImmersiveSession::pollXrEvents() { default: break; } + } else if (event.type == XR_TYPE_EVENT_DATA_INTERACTION_PROFILE_CHANGED) { + auto logProfile = [this](const char *hand, XrPath handPath) { + XrInteractionProfileState profileState{XR_TYPE_INTERACTION_PROFILE_STATE}; + const XrResult result = xrGetCurrentInteractionProfile(session_, handPath, &profileState); + if (XR_FAILED(result) || profileState.interactionProfile == XR_NULL_PATH) { + LOGI("OpenXR active controller profile: %s unavailable result=%d", hand, + static_cast(result)); + return; + } + std::array profile{}; + uint32_t length = 0; + if (XR_SUCCEEDED(xrPathToString(instance_, profileState.interactionProfile, + static_cast(profile.size()), &length, + profile.data()))) { + LOGI("OpenXR active controller profile: %s %s", hand, profile.data()); + } + }; + logProfile("left", handPaths_[0]); + logProfile("right", handPaths_[1]); } event.type = XR_TYPE_EVENT_DATA_BUFFER; } diff --git a/app/src/main/java/app/gamenative/ui/model/MainViewModel.kt b/app/src/main/java/app/gamenative/ui/model/MainViewModel.kt index ca3671bb27..64aed396b7 100644 --- a/app/src/main/java/app/gamenative/ui/model/MainViewModel.kt +++ b/app/src/main/java/app/gamenative/ui/model/MainViewModel.kt @@ -579,7 +579,7 @@ class MainViewModel @Inject constructor( if (app.gamenative.BuildConfig.XR_BUILD && container.isLaunchImmersiveMode() && - app.gamenative.MainActivity.isMetaQuest() + app.gamenative.MainActivity.isHeadset(context) ) { bootingSplashTimeoutJob?.cancel() bootingSplashTimeoutJob = null diff --git a/app/src/main/java/app/gamenative/ui/screen/library/appscreen/BaseAppScreen.kt b/app/src/main/java/app/gamenative/ui/screen/library/appscreen/BaseAppScreen.kt index 4ad7e140ca..ad3aad0a57 100644 --- a/app/src/main/java/app/gamenative/ui/screen/library/appscreen/BaseAppScreen.kt +++ b/app/src/main/java/app/gamenative/ui/screen/library/appscreen/BaseAppScreen.kt @@ -1223,9 +1223,8 @@ abstract class BaseAppScreen { mutableStateOf(hasLeftoverInstall(context, libraryItem)) } - // Immersive/VR launch mode is only offered on the modernXr build running on Meta Quest. val isImmersiveModeSupported = remember(libraryItem.appId) { - app.gamenative.BuildConfig.XR_BUILD && app.gamenative.MainActivity.isMetaQuest() + app.gamenative.BuildConfig.XR_BUILD && app.gamenative.MainActivity.isHeadset(context) } var isImmersiveModeEnabledState by remember(libraryItem.appId) { mutableStateOf(null) } val immersiveModeSaveRequests = remember(libraryItem.appId) { Channel(Channel.CONFLATED) } diff --git a/app/src/main/java/app/gamenative/ui/screen/xr/ImmersiveXrActivity.kt b/app/src/main/java/app/gamenative/ui/screen/xr/ImmersiveXrActivity.kt index 5475492392..25a70ced10 100644 --- a/app/src/main/java/app/gamenative/ui/screen/xr/ImmersiveXrActivity.kt +++ b/app/src/main/java/app/gamenative/ui/screen/xr/ImmersiveXrActivity.kt @@ -187,8 +187,8 @@ class ImmersiveXrActivity : androidx.activity.ComponentActivity() { private var lastMenuDpadKeyCode: Int? = null private var lastMenuDpadHeldSince = 0L private var lastMenuDpadEventTime = 0L - private var lastMenuButtonAPressed = false - private var lastMenuButtonBPressed = false + private var lastMenuConfirmPressed = false + private var lastMenuBackPressed = false private var lastMenuButtonLBPressed = false private var lastMenuButtonRBPressed = false @@ -990,9 +990,15 @@ class ImmersiveXrActivity : androidx.activity.ComponentActivity() { } val buttonAPressed = (buttons and (1 shl XrGamepadBridge.BUTTON_A)) != 0 - if (buttonAPressed && !lastMenuButtonAPressed) { + val triggerPressed = axes[4] > POINTER_GRAB_PRESS_THRESHOLD || axes[5] > POINTER_GRAB_PRESS_THRESHOLD + val confirmPressed = buttonAPressed || triggerPressed + if (confirmPressed && !lastMenuConfirmPressed) { val focusedActivate = quickMenuFocusedActivate?.invoke() - Timber.i("Immersive: A pressed, focusedActivatePresent=%b", focusedActivate != null) + Timber.i( + "Immersive: menu confirm pressed, source=%s focusedActivatePresent=%b", + if (buttonAPressed) "A" else "trigger", + focusedActivate != null, + ) if (focusedActivate != null) { runOnUiThread { focusedActivate.invoke() } } else { @@ -1000,11 +1006,16 @@ class ImmersiveXrActivity : androidx.activity.ComponentActivity() { dispatchMenuKeyEvent(android.view.KeyEvent.KEYCODE_BUTTON_A) } } - lastMenuButtonAPressed = buttonAPressed + lastMenuConfirmPressed = confirmPressed val buttonBPressed = (buttons and (1 shl XrGamepadBridge.BUTTON_B)) != 0 - if (buttonBPressed && !lastMenuButtonBPressed) dispatchMenuKeyEvent(android.view.KeyEvent.KEYCODE_BACK) - lastMenuButtonBPressed = buttonBPressed + val rightStickPressed = (buttons and (1 shl XrGamepadBridge.BUTTON_R3)) != 0 + val backPressed = buttonBPressed || rightStickPressed + if (backPressed && !lastMenuBackPressed) { + Timber.i("Immersive: menu back pressed, source=%s", if (buttonBPressed) "B" else "right-stick") + dispatchMenuKeyEvent(android.view.KeyEvent.KEYCODE_BACK) + } + lastMenuBackPressed = backPressed val stickClickHeld = (buttons and ((1 shl XrGamepadBridge.BUTTON_L3) or (1 shl XrGamepadBridge.BUTTON_R3))) != 0 val buttonLBPressed = (buttons and (1 shl XrGamepadBridge.BUTTON_LB)) != 0 diff --git a/app/src/modernXr/AndroidManifest.xml b/app/src/modernXr/AndroidManifest.xml index 607765a95a..9e5f637c81 100644 --- a/app/src/modernXr/AndroidManifest.xml +++ b/app/src/modernXr/AndroidManifest.xml @@ -70,6 +70,9 @@ + From c8b58c33ee2efe064c8d97b0631cc589a1493908 Mon Sep 17 00:00:00 2001 From: Utkarsh Dalal Date: Sat, 22 Aug 2026 17:12:11 +0530 Subject: [PATCH 03/46] Speed up VR frame production: optimal-tiling render targets, buffered control reads, triple buffering --- .../openxr_runtime/gamenative_control.c | 19 +++- .../unix/gamenative_openxr_unix.c | 107 +++++++++++++++++- 2 files changed, 122 insertions(+), 4 deletions(-) diff --git a/app/src/main/windows/openxr_runtime/gamenative_control.c b/app/src/main/windows/openxr_runtime/gamenative_control.c index bb5212ed29..0e864a7a01 100644 --- a/app/src/main/windows/openxr_runtime/gamenative_control.c +++ b/app/src/main/windows/openxr_runtime/gamenative_control.c @@ -29,11 +29,26 @@ static int send_all(const char *data, int length) { return 0; } +static char receive_buffer[1024]; +static uint32_t receive_buffer_length = 0; +static uint32_t receive_buffer_offset = 0; + +static int receive_byte(char *value) { + if (receive_buffer_offset >= receive_buffer_length) { + int received = recv(control_socket, receive_buffer, sizeof(receive_buffer), 0); + if (received <= 0) return -1; + receive_buffer_length = (uint32_t)received; + receive_buffer_offset = 0; + } + *value = receive_buffer[receive_buffer_offset++]; + return 0; +} + static int receive_line(char *response, uint32_t capacity) { uint32_t length = 0; while (length + 1 < capacity) { char value; - if (recv(control_socket, &value, 1, 0) != 1) return -1; + if (receive_byte(&value) != 0) return -1; if (value == '\n') { response[length] = '\0'; return 0; @@ -51,6 +66,8 @@ int gamenative_control_connect(void) { LeaveCriticalSection(&control_lock); return 0; } + receive_buffer_length = 0; + receive_buffer_offset = 0; control_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); if (control_socket == INVALID_SOCKET) { LeaveCriticalSection(&control_lock); diff --git a/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c b/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c index 2cbd61111e..c82df3e49d 100644 --- a/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c +++ b/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c @@ -496,9 +496,101 @@ static void log_vk_result(const char *operation, VkResult result) log_line(line); } +#if defined(__ANDROID__) +static int ahb_transport_probe(void) +{ + static int cached; + if (cached) return cached > 0; + AHardwareBuffer_Desc descriptor = { + .width = 16, + .height = 16, + .layers = 1, + .format = AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM, + .usage = AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE | + AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT + }; + AHardwareBuffer *buffer = NULL; + if (p_vkGetAndroidHardwareBufferPropertiesANDROID && command_pool && + p_vkCmdCopyImage && AHardwareBuffer_allocate(&descriptor, &buffer) == 0 && buffer) { + AHardwareBuffer_release(buffer); + cached = 1; + log_line("AHardwareBuffer transport available; using optimal-tiling render targets"); + } else { + cached = -1; + log_line("AHardwareBuffer transport unavailable; render targets stay linear/exportable"); + } + return cached > 0; +} +#endif + static int create_image(struct gn_swapchain *swapchain, struct gn_image *out, - uint32_t array_size, uint32_t mip_count, uint32_t sample_count) + uint32_t array_size, uint32_t mip_count, uint32_t sample_count, + int optimal) { + if (optimal) { + VkImageCreateInfo optimal_info = { + .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, + .imageType = VK_IMAGE_TYPE_2D, + .format = swapchain->format, + .extent = {swapchain->width, swapchain->height, 1}, + .mipLevels = mip_count ? mip_count : 1, + .arrayLayers = array_size ? array_size : 1, + .samples = sample_count == 2 ? VK_SAMPLE_COUNT_2_BIT : + sample_count == 4 ? VK_SAMPLE_COUNT_4_BIT : + sample_count == 8 ? VK_SAMPLE_COUNT_8_BIT : VK_SAMPLE_COUNT_1_BIT, + .tiling = VK_IMAGE_TILING_OPTIMAL, + .usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | + VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT, + .sharingMode = VK_SHARING_MODE_EXCLUSIVE, + .initialLayout = VK_IMAGE_LAYOUT_UNDEFINED + }; + VkResult optimal_result = p_vkCreateImage(device, &optimal_info, NULL, &out->image); + if (optimal_result != VK_SUCCESS) { + log_vk_result("vkCreateImage(optimal)", optimal_result); + goto optimal_fail; + } + VkMemoryRequirements optimal_requirements; + p_vkGetImageMemoryRequirements(device, out->image, &optimal_requirements); + int optimal_type = find_memory_type( + optimal_requirements.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT); + if (optimal_type < 0) + optimal_type = find_memory_type(optimal_requirements.memoryTypeBits, 0); + if (optimal_type < 0) { + log_line("No compatible memory type for optimal image"); + goto optimal_fail; + } + VkMemoryDedicatedAllocateInfo optimal_dedicated = { + .sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, + .image = out->image + }; + VkMemoryAllocateInfo optimal_allocate = { + .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, + .pNext = &optimal_dedicated, + .allocationSize = optimal_requirements.size, + .memoryTypeIndex = (uint32_t)optimal_type + }; + optimal_result = p_vkAllocateMemory(device, &optimal_allocate, NULL, &out->memory); + if (optimal_result != VK_SUCCESS) { + log_vk_result("vkAllocateMemory(optimal)", optimal_result); + goto optimal_fail; + } + optimal_result = p_vkBindImageMemory(device, out->image, out->memory, 0); + if (optimal_result != VK_SUCCESS) { + log_vk_result("vkBindImageMemory(optimal)", optimal_result); + goto optimal_fail; + } + out->dma_buf_fd = -1; + out->plane_count = 0; + out->modifier = 0; + return 1; + optimal_fail: + if (out->memory && p_vkFreeMemory) p_vkFreeMemory(device, out->memory, NULL); + out->memory = VK_NULL_HANDLE; + if (out->image && p_vkDestroyImage) p_vkDestroyImage(device, out->image, NULL); + out->image = VK_NULL_HANDLE; + return 0; + } + VkExternalMemoryImageCreateInfo external = { .sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, .handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT @@ -1033,6 +1125,11 @@ static int register_image(uint32_t slot, uint32_t image_index, uint32_t eye, return 1; } + if (image->dma_buf_fd < 0) { + log_line("optimal render image has no dma-buf; AHardwareBuffer transport is required"); + return 0; + } + VkSubresourceLayout layouts[4]; for (uint32_t plane = 0; plane < image->plane_count; ++plane) { VkImageSubresource subresource = { @@ -1274,11 +1371,15 @@ static int32_t unix_create_swapchain(void *opaque) swapchain->sample_count = args->sample_count ? args->sample_count : 1; - swapchain->image_count = 2; + swapchain->image_count = 3; + int optimal = 0; +#if defined(__ANDROID__) + optimal = swapchain->sample_count == 1 && ahb_transport_probe(); +#endif for (uint32_t i = 0; i < swapchain->image_count; ++i) { swapchain->images[i].dma_buf_fd = -1; if (!create_image(swapchain, &swapchain->images[i], args->array_size, - args->mip_count, args->sample_count)) { + args->mip_count, args->sample_count, optimal)) { for (uint32_t j = 0; j <= i; ++j) destroy_image(&swapchain->images[j]); memset(swapchain, 0, sizeof(*swapchain)); args->result = GN_UNIX_ERROR_VULKAN; From a3a3a097214908d80548356605b7e87893daa511 Mon Sep 17 00:00:00 2001 From: Utkarsh Dalal Date: Sat, 22 Aug 2026 17:21:21 +0530 Subject: [PATCH 04/46] Skip the Windows-only XR payload scripts on non-Windows hosts --- app/build.gradle.kts | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/app/build.gradle.kts b/app/build.gradle.kts index b5b6d6c450..399f57028a 100644 --- a/app/build.gradle.kts +++ b/app/build.gradle.kts @@ -283,7 +283,10 @@ android { ignoreFormatFailures = false } + val hostCanRunXrPayloadScripts = System.getProperty("os.name").startsWith("Windows") + tasks.register("buildModernXrNative") { + enabled = hostCanRunXrPayloadScripts commandLine( "powershell", "-ExecutionPolicy", @@ -294,6 +297,7 @@ android { } tasks.register("buildWindowsXrRuntime") { + enabled = hostCanRunXrPayloadScripts commandLine( "powershell", "-ExecutionPolicy", @@ -304,6 +308,7 @@ android { } tasks.register("stageWineXrBridge") { + enabled = hostCanRunXrPayloadScripts val companion = providers.environmentVariable("GAMENATIVE_WINE_XR_BRIDGE") doFirst { check(companion.isPresent) { "GAMENATIVE_WINE_XR_BRIDGE must point to the ARM64X Wine builtin companion" } @@ -320,6 +325,7 @@ android { } tasks.register("stageOpenComposite") { + enabled = hostCanRunXrPayloadScripts commandLine( "powershell", "-ExecutionPolicy", @@ -330,6 +336,7 @@ android { } tasks.register("verifyModernXrPayload") { + enabled = hostCanRunXrPayloadScripts dependsOn("buildModernXrNative", "buildWindowsXrRuntime", "stageWineXrBridge", "stageOpenComposite") commandLine( "powershell", From 914bc7f137aba3d299f8fb1637f89451f3e452f3 Mon Sep 17 00:00:00 2001 From: Utkarsh Dalal Date: Sat, 22 Aug 2026 18:07:51 +0530 Subject: [PATCH 05/46] Keep the VR control connection alive: drop the per-connection request cap, buffer the runtime's socket reads --- .../xr/windows/WindowsVrControlServer.kt | 5 ++--- .../gamenative_openxr_runtime.c | 21 ++++++++++++++++--- 2 files changed, 20 insertions(+), 6 deletions(-) diff --git a/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrControlServer.kt b/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrControlServer.kt index d53d4750cd..6299f08ba2 100644 --- a/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrControlServer.kt +++ b/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrControlServer.kt @@ -45,12 +45,11 @@ class WindowsVrControlServer( private fun handle(socket: Socket) { try { socket.tcpNoDelay = true - socket.soTimeout = 15000 + socket.soTimeout = 120000 val input = socket.getInputStream() val writer = BufferedWriter(OutputStreamWriter(socket.getOutputStream(), Charsets.US_ASCII), 1024) - var requests = 0 var greeted = false - while (running.get() && requests++ < 1024) { + while (running.get()) { val line = readBoundedLine(input) ?: break if (!greeted && line != "HELLO") break val response = respond(line) diff --git a/app/src/main/windows/openxr_runtime/gamenative_openxr_runtime.c b/app/src/main/windows/openxr_runtime/gamenative_openxr_runtime.c index 34f4147ba5..81524aa322 100644 --- a/app/src/main/windows/openxr_runtime/gamenative_openxr_runtime.c +++ b/app/src/main/windows/openxr_runtime/gamenative_openxr_runtime.c @@ -573,6 +573,20 @@ static int gn_stopping_pushed = 0; static int gn_winsock_started = 0; static gn_socket gn_bridge_socket = GN_INVALID_SOCKET; static int gn_bridge_ever_connected = 0; +static char gn_bridge_rxbuf[1024]; +static gn_size gn_bridge_rxlen = 0; +static gn_size gn_bridge_rxoff = 0; + +static int gn_bridge_recv_byte(char* value) { + if (gn_bridge_rxoff >= gn_bridge_rxlen) { + int got = recv(gn_bridge_socket, gn_bridge_rxbuf, (int)sizeof(gn_bridge_rxbuf), 0); + if (got <= 0) return 0; + gn_bridge_rxlen = (gn_size)got; + gn_bridge_rxoff = 0; + } + *value = gn_bridge_rxbuf[gn_bridge_rxoff++]; + return 1; +} static int gn_frame_milestone_sent = 0; static XrSessionState gn_event_states[16]; static gn_uint32 gn_event_head = 0; @@ -1132,6 +1146,8 @@ static int gn_bridge_call_locked(const char* command, char* response, gn_size re out[0] = 0; if (gn_bridge_socket == GN_INVALID_SOCKET) { if (!gn_bridge_connect_locked()) return 0; + gn_bridge_rxlen = 0; + gn_bridge_rxoff = 0; { char hello[64]; @@ -1142,7 +1158,7 @@ static int gn_bridge_call_locked(const char* command, char* response, gn_size re } gn_size hoff = 0; while (hoff + 1 < sizeof(hello)) { - if (recv(gn_bridge_socket, &ch, 1, 0) <= 0) { + if (!gn_bridge_recv_byte(&ch)) { gn_bridge_close(); return 0; } @@ -1173,8 +1189,7 @@ static int gn_bridge_call_locked(const char* command, char* response, gn_size re } while (offset + 1 < out_size) { - got = recv(gn_bridge_socket, &ch, 1, 0); - if (got <= 0) { + if (!gn_bridge_recv_byte(&ch)) { gn_bridge_close(); gn_log2("bridge recv failed for: ", command); return 0; From 336c60a4f4fcf042a79a34a8e4d8a103d0235395 Mon Sep 17 00:00:00 2001 From: Utkarsh Dalal Date: Sat, 22 Aug 2026 18:45:35 +0530 Subject: [PATCH 06/46] Collapse per-frame control traffic into one FRAME_SYNC round trip --- .../xr/windows/WindowsVrControlServer.kt | 17 ++++- .../gamenative_openxr_runtime.c | 71 +++++++++++++++++-- 2 files changed, 80 insertions(+), 8 deletions(-) diff --git a/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrControlServer.kt b/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrControlServer.kt index 6299f08ba2..999f4a9b20 100644 --- a/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrControlServer.kt +++ b/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrControlServer.kt @@ -88,6 +88,7 @@ class WindowsVrControlServer( "GET_VIEWS" -> if (tokens.size == 1) getViews() else "ERROR malformed" "GET_BOUNDS" -> if (tokens.size == 1) getBounds() else "ERROR malformed" "WAIT_FRAME" -> if (tokens.size == 1) waitFrame() else "ERROR malformed" + "FRAME_SYNC" -> if (tokens.size == 1) frameSync() else "ERROR malformed" "LOCATE_VIEWS" -> if (tokens.size == 1) locateViews() else "ERROR malformed" "GET_INPUT" -> getInput(tokens) "HAPTIC" -> haptic(tokens) @@ -141,6 +142,16 @@ class WindowsVrControlServer( return "OK" } + /** One round-trip for the whole per-frame state: frame timing, view poses, and both + * hands' input as four lines. Saves three guest-side TCP round trips every frame. */ + private fun frameSync(): String { + val frame = waitFrame() + if (!frame.startsWith("OK")) return frame + return frame + "\n" + locateViews() + "\n" + + getInput(listOf("GET_INPUT", "hand=0")) + "\n" + + getInput(listOf("GET_INPUT", "hand=1")) + } + private fun waitFrame(): String { val snapshot = snapshots.waitFrame(lastFrameSerial, 1000) ?: return "ERROR timeout" lastFrameSerial = snapshot.timing[0] @@ -161,7 +172,11 @@ class WindowsVrControlServer( private fun getViews(): String { val snapshot = currentSnapshot() ?: return "ERROR unavailable" - return "OK count=2 width=${snapshot.timing[5]} height=${snapshot.timing[6]}" + // The recommended per-eye size is far beyond what an emulated producer can fill; + // halve it (even dimensions) — quarter the pixels for render, copy, and upload. + val scaledWidth = (snapshot.timing[5] / 2) and 1L.inv() + val scaledHeight = (snapshot.timing[6] / 2) and 1L.inv() + return "OK count=2 width=$scaledWidth height=$scaledHeight" } private fun getBounds(): String { diff --git a/app/src/main/windows/openxr_runtime/gamenative_openxr_runtime.c b/app/src/main/windows/openxr_runtime/gamenative_openxr_runtime.c index 81524aa322..f6928a4c0a 100644 --- a/app/src/main/windows/openxr_runtime/gamenative_openxr_runtime.c +++ b/app/src/main/windows/openxr_runtime/gamenative_openxr_runtime.c @@ -1209,6 +1209,56 @@ static int gn_bridge_call(const char* command, char* response, gn_size response_ return ok; } +static char gn_cached_views[512]; +static char gn_cached_input[2][512]; +static int gn_cache_valid = 0; +static int gn_frame_sync_supported = 1; + +static int gn_bridge_read_line_locked(char* out, gn_size out_size) { + gn_size offset = 0; + char ch = 0; + while (offset + 1 < out_size) { + if (!gn_bridge_recv_byte(&ch)) { + gn_bridge_close(); + return 0; + } + if (ch == '\n') break; + out[offset++] = ch; + } + out[offset] = 0; + return gn_starts_with(out, "OK"); +} + +static int gn_bridge_frame_sync(char* frame_out, gn_size frame_size) { + int ok; + gn_lock_acquire(); + gn_cache_valid = 0; + ok = gn_bridge_call_locked("FRAME_SYNC", frame_out, frame_size); + if (ok) { + ok = gn_bridge_read_line_locked(gn_cached_views, sizeof(gn_cached_views)) && + gn_bridge_read_line_locked(gn_cached_input[0], sizeof(gn_cached_input[0])) && + gn_bridge_read_line_locked(gn_cached_input[1], sizeof(gn_cached_input[1])); + gn_cache_valid = ok; + } else if (gn_starts_with(frame_out, "ERROR")) { + gn_frame_sync_supported = 0; + gn_log_line("FRAME_SYNC unsupported by bridge; using separate per-frame requests"); + } + gn_lock_release(); + return ok; +} + +static int gn_cached_line(const char* which, int hand, char* out, gn_size out_size) { + int ok = 0; + gn_lock_acquire(); + if (gn_cache_valid) { + if (which[0] == 'v') gn_copy(out, out_size, gn_cached_views); + else gn_copy(out, out_size, gn_cached_input[hand]); + ok = 1; + } + gn_lock_release(); + return ok; +} + @@ -1353,11 +1403,13 @@ static void gn_refresh_hand(int hand) { gn_size n; GnHandState* h = &gn_hands[hand]; - n = gn_append(cmd, sizeof(cmd), 0, "GET_INPUT hand="); - n = gn_append_i64(cmd, sizeof(cmd), n, hand); - if (!gn_bridge_call(cmd, response, sizeof(response))) { - h->active = 0; - return; + if (!gn_cached_line("input", hand, response, sizeof(response))) { + n = gn_append(cmd, sizeof(cmd), 0, "GET_INPUT hand="); + n = gn_append_i64(cmd, sizeof(cmd), n, hand); + if (!gn_bridge_call(cmd, response, sizeof(response))) { + h->active = 0; + return; + } } h->active = (int)gn_parse_i64(response, "active", 0); @@ -2182,8 +2234,12 @@ static XrResult XRAPI_CALL gn_xrLocateSpaces( static XrResult XRAPI_CALL gn_xrWaitFrame(XrSession session, const XrFrameWaitInfo* waitInfo, XrFrameState* frameState) { (void)waitInfo; char response[160]; + int synced; if (session != gn_session || !frameState) return XR_ERROR_HANDLE_INVALID; - if (gn_bridge_call("WAIT_FRAME", response, sizeof(response))) { + synced = gn_frame_sync_supported && gn_bridge_frame_sync(response, sizeof(response)); + if (!synced && !gn_frame_sync_supported) + synced = gn_bridge_call("WAIT_FRAME", response, sizeof(response)); + if (synced) { frameState->predictedDisplayTime = gn_parse_i64(response, "time", gn_next_display_time); frameState->predictedDisplayPeriod = gn_parse_i64(response, "period", 11111111); frameState->shouldRender = gn_parse_i64(response, "render", gn_session_running ? 1 : 0) != 0 ? XR_TRUE : XR_FALSE; @@ -2391,7 +2447,8 @@ static XrResult XRAPI_CALL gn_xrLocateViews( return XR_ERROR_VALIDATION_FAILURE; } - if (gn_bridge_call("LOCATE_VIEWS", response, sizeof(response))) { + if (gn_cached_line("views", 0, response, sizeof(response)) || + gn_bridge_call("LOCATE_VIEWS", response, sizeof(response))) { static const char* qk[2][4] = {{"lqx", "lqy", "lqz", "lqw"}, {"rqx", "rqy", "rqz", "rqw"}}; static const char* pk[2][3] = {{"lpx", "lpy", "lpz"}, {"rpx", "rpy", "rpz"}}; static const char* fk[2][4] = {{"lfl", "lfr", "lfu", "lfd"}, {"rfl", "rfr", "rfu", "rfd"}}; From 9b3f00207715743a6612631c420c8155ac47b229 Mon Sep 17 00:00:00 2001 From: Utkarsh Dalal Date: Sat, 22 Aug 2026 18:57:04 +0530 Subject: [PATCH 07/46] Log the consumer buffer path and swapchain sample count --- app/src/main/cpp/xrimmersive/xr_windows_projection.cpp | 7 +++++++ .../windows/openxr_runtime/unix/gamenative_openxr_unix.c | 3 ++- 2 files changed, 9 insertions(+), 1 deletion(-) diff --git a/app/src/main/cpp/xrimmersive/xr_windows_projection.cpp b/app/src/main/cpp/xrimmersive/xr_windows_projection.cpp index 7145f97833..c1510661b4 100644 --- a/app/src/main/cpp/xrimmersive/xr_windows_projection.cpp +++ b/app/src/main/cpp/xrimmersive/xr_windows_projection.cpp @@ -8,6 +8,10 @@ #include #include +#include + +#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, "xrimmersive", __VA_ARGS__) + namespace xrimmersive::windowsvr { namespace { @@ -303,7 +307,10 @@ bool WindowsProjectionPresenter::importEyeBuffer(WindowsFrameTransport &transpor imported = createImageFromDmabuf(frame); if (imported == EGL_NO_IMAGE_KHR) { cpuFallback_[eye][image] = true; + LOGI("windows vr eye %u image %d: EGL dma-buf import failed — CPU upload fallback engaged", eye, image); if (uploadLinearDmabufToTexture(eye, image, frame, cachedTexture, registration)) return true; + } else { + LOGI("windows vr eye %u image %d: zero-copy EGL dma-buf import active", eye, image); } } if (imported == EGL_NO_IMAGE_KHR) { diff --git a/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c b/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c index c82df3e49d..0f15ef0851 100644 --- a/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c +++ b/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c @@ -756,10 +756,11 @@ static int create_image(struct gn_swapchain *swapchain, struct gn_image *out, { char trace[320]; snprintf(trace, sizeof(trace), - "dma-buf image format=%d size=%ux%u layers=%u tiling=%s " + "dma-buf image format=%d size=%ux%u layers=%u samples=%u tiling=%s " "modifier=0x%llx planes=%u stride0=%u offset0=%u", (int)swapchain->format, swapchain->width, swapchain->height, array_size ? array_size : 1, + sample_count ? sample_count : 1, has_chosen_modifier ? "modifier" : "linear", (unsigned long long)out->modifier, out->plane_count, out->strides[0], out->offsets[0]); From 566393eab9e3c984bc1d619f7536733b9103ed23 Mon Sep 17 00:00:00 2001 From: Utkarsh Dalal Date: Sun, 23 Aug 2026 00:11:03 +0530 Subject: [PATCH 08/46] Relay device: GPU dma-buf to AHardwareBuffer copies when the game device lacks AHB support --- .../unix/gamenative_openxr_unix.c | 634 +++++++++++++++++- 1 file changed, 633 insertions(+), 1 deletion(-) diff --git a/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c b/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c index 0f15ef0851..5a527cee91 100644 --- a/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c +++ b/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c @@ -32,7 +32,8 @@ typedef int32_t (*unixlib_entry_t)(void *); enum gn_transport_kind { GN_TRANSPORT_UNKNOWN = 0, GN_TRANSPORT_AHARDWAREBUFFER = 1, - GN_TRANSPORT_DMABUF = 2 + GN_TRANSPORT_DMABUF = 2, + GN_TRANSPORT_RELAY = 3 }; struct gn_transport_image { @@ -40,6 +41,7 @@ struct gn_transport_image { VkDeviceMemory memory; VkCommandBuffer command_buffer; void *hardware_buffer; + uint8_t relay; uint8_t registered; uint8_t initialized; uint8_t steady_recorded; @@ -62,6 +64,8 @@ struct gn_image { uint32_t registered_array_index[2]; uint8_t transport_kind[2]; struct gn_transport_image transport[2]; + VkImage relay_source_image; + VkDeviceMemory relay_source_memory; uint8_t submitted; }; @@ -778,8 +782,582 @@ static int create_image(struct gn_swapchain *swapchain, struct gn_image *out, return 0; } +#if defined(__ANDROID__) +/* Relay: a second Vulkan device (turnip, or the system driver) used when the game's + * host device was created without the Android hardware-buffer extension. The game's + * linear dma-buf render image is imported here and GPU-copied into an AHardwareBuffer + * so the compositor gets the zero-copy path instead of a per-frame CPU upload. */ +static void *relay_lib; +static VkInstance relay_instance; +static VkPhysicalDevice relay_phys; +static VkDevice relay_device; +static VkQueue relay_queue; +static uint32_t relay_queue_family; +static VkCommandPool relay_pool; +static int relay_state; /* 0 untried, 1 ready, -1 unavailable */ +static int relay_can_export_fence; + +static PFN_vkGetDeviceProcAddr r_vkGetDeviceProcAddr; +static PFN_vkCreateImage r_vkCreateImage; +static PFN_vkDestroyImage r_vkDestroyImage; +static PFN_vkGetImageMemoryRequirements r_vkGetImageMemoryRequirements; +static PFN_vkAllocateMemory r_vkAllocateMemory; +static PFN_vkFreeMemory r_vkFreeMemory; +static PFN_vkBindImageMemory r_vkBindImageMemory; +static PFN_vkCreateCommandPool r_vkCreateCommandPool; +static PFN_vkAllocateCommandBuffers r_vkAllocateCommandBuffers; +static PFN_vkFreeCommandBuffers r_vkFreeCommandBuffers; +static PFN_vkResetCommandBuffer r_vkResetCommandBuffer; +static PFN_vkBeginCommandBuffer r_vkBeginCommandBuffer; +static PFN_vkEndCommandBuffer r_vkEndCommandBuffer; +static PFN_vkCmdPipelineBarrier r_vkCmdPipelineBarrier; +static PFN_vkCmdCopyImage r_vkCmdCopyImage; +static PFN_vkQueueSubmit r_vkQueueSubmit; +static PFN_vkQueueWaitIdle r_vkQueueWaitIdle; +static PFN_vkCreateFence r_vkCreateFence; +static PFN_vkDestroyFence r_vkDestroyFence; +static PFN_vkGetFenceFdKHR r_vkGetFenceFdKHR; +static PFN_vkGetAndroidHardwareBufferPropertiesANDROID r_vkGetAndroidHardwareBufferPropertiesANDROID; +static PFN_vkGetMemoryFdPropertiesKHR r_vkGetMemoryFdPropertiesKHR; +static PFN_vkGetPhysicalDeviceMemoryProperties r_vkGetPhysicalDeviceMemoryProperties; + +static int relay_find_memory_type(uint32_t type_bits, VkMemoryPropertyFlags wanted) +{ + VkPhysicalDeviceMemoryProperties properties; + r_vkGetPhysicalDeviceMemoryProperties(relay_phys, &properties); + for (uint32_t i = 0; i < properties.memoryTypeCount; ++i) { + if ((type_bits & (1u << i)) && + (properties.memoryTypes[i].propertyFlags & wanted) == wanted) + return (int)i; + } + return -1; +} + +static int relay_init(void) +{ + if (relay_state) return relay_state > 0; + relay_state = -1; + + static const char *candidates[] = { + "libvulkan_freedreno.so", "libvulkan.so", NULL + }; + PFN_vkGetInstanceProcAddr gipa = NULL; + for (int i = 0; candidates[i] && !gipa; ++i) { + relay_lib = dlopen(candidates[i], RTLD_NOW | RTLD_LOCAL); + if (!relay_lib) continue; + gipa = (PFN_vkGetInstanceProcAddr)dlsym(relay_lib, "vk_icdGetInstanceProcAddr"); + if (!gipa) gipa = (PFN_vkGetInstanceProcAddr)dlsym(relay_lib, "vkGetInstanceProcAddr"); + if (!gipa) { dlclose(relay_lib); relay_lib = NULL; continue; } + { + char trace[128]; + snprintf(trace, sizeof(trace), "relay: using %s", candidates[i]); + log_line(trace); + } + } + if (!gipa) { log_line("relay: no usable Vulkan driver"); return 0; } + + PFN_vkCreateInstance create_instance = + (PFN_vkCreateInstance)gipa(NULL, "vkCreateInstance"); + if (!create_instance) return 0; + VkApplicationInfo app = { + .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO, + .pApplicationName = "gamenative-xr-relay", + .apiVersion = VK_API_VERSION_1_1 + }; + VkInstanceCreateInfo instance_info = { + .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, + .pApplicationInfo = &app + }; + if (create_instance(&instance_info, NULL, &relay_instance) != VK_SUCCESS) { + log_line("relay: vkCreateInstance failed"); + return 0; + } + +#define RELAY_ILOAD(name) PFN_##name i_##name = (PFN_##name)gipa(relay_instance, #name) + RELAY_ILOAD(vkEnumeratePhysicalDevices); + RELAY_ILOAD(vkGetPhysicalDeviceQueueFamilyProperties); + RELAY_ILOAD(vkEnumerateDeviceExtensionProperties); + RELAY_ILOAD(vkCreateDevice); + RELAY_ILOAD(vkGetDeviceProcAddr); + RELAY_ILOAD(vkGetPhysicalDeviceMemoryProperties); +#undef RELAY_ILOAD + if (!i_vkEnumeratePhysicalDevices || !i_vkGetPhysicalDeviceQueueFamilyProperties || + !i_vkEnumerateDeviceExtensionProperties || !i_vkCreateDevice || + !i_vkGetDeviceProcAddr || !i_vkGetPhysicalDeviceMemoryProperties) + return 0; + r_vkGetPhysicalDeviceMemoryProperties = i_vkGetPhysicalDeviceMemoryProperties; + + uint32_t count = 1; + if (i_vkEnumeratePhysicalDevices(relay_instance, &count, &relay_phys) < 0 || !count) { + log_line("relay: no physical device"); + return 0; + } + + VkQueueFamilyProperties families[8]; + uint32_t family_count = 8; + i_vkGetPhysicalDeviceQueueFamilyProperties(relay_phys, &family_count, families); + relay_queue_family = 0; + for (uint32_t i = 0; i < family_count; ++i) { + if (families[i].queueFlags & (VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_TRANSFER_BIT)) { + relay_queue_family = i; + break; + } + } + + static const char *wanted[] = { + "VK_ANDROID_external_memory_android_hardware_buffer", + "VK_EXT_external_memory_dma_buf", + "VK_KHR_external_memory_fd", + "VK_EXT_queue_family_foreign", + "VK_KHR_sampler_ycbcr_conversion", + "VK_KHR_external_fence_fd", + "VK_KHR_dedicated_allocation", + "VK_KHR_get_memory_requirements2", + "VK_KHR_bind_memory2", + "VK_KHR_maintenance1", + "VK_KHR_external_memory" + }; + VkExtensionProperties supported[256]; + uint32_t supported_count = 256; + if (i_vkEnumerateDeviceExtensionProperties(relay_phys, NULL, &supported_count, supported) < 0) + return 0; + const char *enabled[16]; + uint32_t enabled_count = 0; + int have_ahb = 0, have_dmabuf = 0, have_fd = 0; + for (uint32_t w = 0; w < sizeof(wanted) / sizeof(wanted[0]); ++w) { + for (uint32_t i = 0; i < supported_count; ++i) { + if (strcmp(supported[i].extensionName, wanted[w]) == 0) { + enabled[enabled_count++] = wanted[w]; + if (w == 0) have_ahb = 1; + if (w == 1) have_dmabuf = 1; + if (w == 2) have_fd = 1; + if (w == 5) relay_can_export_fence = 1; + break; + } + } + } + if (!have_ahb || !have_dmabuf || !have_fd) { + char trace[128]; + snprintf(trace, sizeof(trace), "relay: missing extensions ahb=%d dmabuf=%d fd=%d", + have_ahb, have_dmabuf, have_fd); + log_line(trace); + return 0; + } + + float priority = 1.0f; + VkDeviceQueueCreateInfo queue_info = { + .sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, + .queueFamilyIndex = relay_queue_family, + .queueCount = 1, + .pQueuePriorities = &priority + }; + VkDeviceCreateInfo device_info = { + .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, + .queueCreateInfoCount = 1, + .pQueueCreateInfos = &queue_info, + .enabledExtensionCount = enabled_count, + .ppEnabledExtensionNames = enabled + }; + if (i_vkCreateDevice(relay_phys, &device_info, NULL, &relay_device) != VK_SUCCESS) { + log_line("relay: vkCreateDevice failed"); + return 0; + } + r_vkGetDeviceProcAddr = i_vkGetDeviceProcAddr; + +#define RELAY_DLOAD(name) \ + r_##name = (PFN_##name)r_vkGetDeviceProcAddr(relay_device, #name); \ + if (!r_##name) { log_line("relay: missing " #name); return 0; } + RELAY_DLOAD(vkCreateImage); + RELAY_DLOAD(vkDestroyImage); + RELAY_DLOAD(vkGetImageMemoryRequirements); + RELAY_DLOAD(vkAllocateMemory); + RELAY_DLOAD(vkFreeMemory); + RELAY_DLOAD(vkBindImageMemory); + RELAY_DLOAD(vkCreateCommandPool); + RELAY_DLOAD(vkAllocateCommandBuffers); + RELAY_DLOAD(vkFreeCommandBuffers); + RELAY_DLOAD(vkResetCommandBuffer); + RELAY_DLOAD(vkBeginCommandBuffer); + RELAY_DLOAD(vkEndCommandBuffer); + RELAY_DLOAD(vkCmdPipelineBarrier); + RELAY_DLOAD(vkCmdCopyImage); + RELAY_DLOAD(vkQueueSubmit); + RELAY_DLOAD(vkQueueWaitIdle); + RELAY_DLOAD(vkCreateFence); + RELAY_DLOAD(vkDestroyFence); + RELAY_DLOAD(vkGetAndroidHardwareBufferPropertiesANDROID); + RELAY_DLOAD(vkGetMemoryFdPropertiesKHR); +#undef RELAY_DLOAD + r_vkGetFenceFdKHR = (PFN_vkGetFenceFdKHR)r_vkGetDeviceProcAddr(relay_device, "vkGetFenceFdKHR"); + if (!r_vkGetFenceFdKHR) relay_can_export_fence = 0; + + PFN_vkGetDeviceQueue get_queue = + (PFN_vkGetDeviceQueue)r_vkGetDeviceProcAddr(relay_device, "vkGetDeviceQueue"); + if (!get_queue) return 0; + get_queue(relay_device, relay_queue_family, 0, &relay_queue); + + VkCommandPoolCreateInfo pool_info = { + .sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, + .flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, + .queueFamilyIndex = relay_queue_family + }; + if (r_vkCreateCommandPool(relay_device, &pool_info, NULL, &relay_pool) != VK_SUCCESS) { + log_line("relay: command pool failed"); + return 0; + } + relay_state = 1; + log_line("relay: ready — GPU dma-buf to AHardwareBuffer copies enabled"); + return 1; +} + +static int relay_create_source(struct gn_swapchain *swapchain, struct gn_image *image) +{ + if (image->relay_source_image) return 1; + if (image->dma_buf_fd < 0) return 0; + int fd = dup(image->dma_buf_fd); + if (fd < 0) return 0; + + VkMemoryFdPropertiesKHR fd_properties = { + .sType = VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR + }; + if (r_vkGetMemoryFdPropertiesKHR( + relay_device, VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT, + fd, &fd_properties) != VK_SUCCESS) { + log_line("relay: vkGetMemoryFdPropertiesKHR failed"); + close(fd); + return 0; + } + + VkExternalMemoryImageCreateInfo external = { + .sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, + .handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT + }; + VkImageCreateInfo image_info = { + .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, + .pNext = &external, + .imageType = VK_IMAGE_TYPE_2D, + .format = swapchain->format, + .extent = {swapchain->width, swapchain->height, 1}, + .mipLevels = 1, + .arrayLayers = swapchain->array_size ? swapchain->array_size : 1, + .samples = VK_SAMPLE_COUNT_1_BIT, + .tiling = VK_IMAGE_TILING_LINEAR, + .usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT, + .sharingMode = VK_SHARING_MODE_EXCLUSIVE, + .initialLayout = VK_IMAGE_LAYOUT_UNDEFINED + }; + if (r_vkCreateImage(relay_device, &image_info, NULL, &image->relay_source_image) != VK_SUCCESS) { + log_line("relay: source image create failed"); + close(fd); + return 0; + } + VkMemoryRequirements requirements; + r_vkGetImageMemoryRequirements(relay_device, image->relay_source_image, &requirements); + int memory_type = relay_find_memory_type( + requirements.memoryTypeBits & fd_properties.memoryTypeBits, 0); + if (memory_type < 0) { + log_line("relay: no memory type for source"); + goto fail; + } + VkImportMemoryFdInfoKHR import_info = { + .sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR, + .handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT, + .fd = fd + }; + VkMemoryDedicatedAllocateInfo dedicated = { + .sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, + .pNext = &import_info, + .image = image->relay_source_image + }; + VkMemoryAllocateInfo allocate_info = { + .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, + .pNext = &dedicated, + .allocationSize = requirements.size, + .memoryTypeIndex = (uint32_t)memory_type + }; + if (r_vkAllocateMemory(relay_device, &allocate_info, NULL, &image->relay_source_memory) != VK_SUCCESS) { + log_line("relay: source import failed"); + goto fail; + } + fd = -1; /* consumed by the import */ + if (r_vkBindImageMemory(relay_device, image->relay_source_image, + image->relay_source_memory, 0) != VK_SUCCESS) { + log_line("relay: source bind failed"); + goto fail; + } + return 1; +fail: + if (fd >= 0) close(fd); + if (image->relay_source_memory) { + r_vkFreeMemory(relay_device, image->relay_source_memory, NULL); + image->relay_source_memory = VK_NULL_HANDLE; + } + if (image->relay_source_image) { + r_vkDestroyImage(relay_device, image->relay_source_image, NULL); + image->relay_source_image = VK_NULL_HANDLE; + } + return 0; +} + +static int relay_create_transport( + const struct gn_swapchain *swapchain, struct gn_transport_image *transport) +{ + AHardwareBuffer_Desc descriptor = { + .width = swapchain->width, + .height = swapchain->height, + .layers = 1, + .format = AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM, + .usage = AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE | + AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT + }; + AHardwareBuffer *buffer = NULL; + if (AHardwareBuffer_allocate(&descriptor, &buffer) != 0 || !buffer) { + log_line("relay: AHardwareBuffer allocation failed"); + return 0; + } + transport->hardware_buffer = buffer; + transport->relay = 1; + + VkAndroidHardwareBufferPropertiesANDROID properties = { + .sType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID + }; + if (r_vkGetAndroidHardwareBufferPropertiesANDROID(relay_device, buffer, &properties) != VK_SUCCESS) { + log_line("relay: AHB properties failed"); + return 0; + } + VkExternalMemoryImageCreateInfo external = { + .sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, + .handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID + }; + VkImageCreateInfo image_info = { + .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, + .pNext = &external, + .imageType = VK_IMAGE_TYPE_2D, + .format = VK_FORMAT_R8G8B8A8_UNORM, + .extent = {swapchain->width, swapchain->height, 1}, + .mipLevels = 1, + .arrayLayers = 1, + .samples = VK_SAMPLE_COUNT_1_BIT, + .tiling = VK_IMAGE_TILING_OPTIMAL, + .usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT, + .sharingMode = VK_SHARING_MODE_EXCLUSIVE, + .initialLayout = VK_IMAGE_LAYOUT_UNDEFINED + }; + if (r_vkCreateImage(relay_device, &image_info, NULL, &transport->image) != VK_SUCCESS) { + log_line("relay: transport image failed"); + return 0; + } + VkMemoryRequirements requirements; + r_vkGetImageMemoryRequirements(relay_device, transport->image, &requirements); + int memory_type = relay_find_memory_type( + requirements.memoryTypeBits & properties.memoryTypeBits, 0); + if (memory_type < 0) { + log_line("relay: no memory type for transport"); + return 0; + } + VkImportAndroidHardwareBufferInfoANDROID import_info = { + .sType = VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID, + .buffer = buffer + }; + VkMemoryDedicatedAllocateInfo dedicated = { + .sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, + .pNext = &import_info, + .image = transport->image + }; + VkMemoryAllocateInfo allocate_info = { + .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, + .pNext = &dedicated, + .allocationSize = properties.allocationSize, + .memoryTypeIndex = (uint32_t)memory_type + }; + if (r_vkAllocateMemory(relay_device, &allocate_info, NULL, &transport->memory) != VK_SUCCESS || + r_vkBindImageMemory(relay_device, transport->image, transport->memory, 0) != VK_SUCCESS) { + log_line("relay: transport memory failed"); + return 0; + } + VkCommandBufferAllocateInfo command_info = { + .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, + .commandPool = relay_pool, + .level = VK_COMMAND_BUFFER_LEVEL_PRIMARY, + .commandBufferCount = 1 + }; + if (r_vkAllocateCommandBuffers(relay_device, &command_info, &transport->command_buffer) != VK_SUCCESS) { + log_line("relay: command buffer failed"); + return 0; + } + return 1; +} + +static int relay_record_copy( + const struct gn_swapchain *swapchain, struct gn_image *image, + struct gn_transport_image *transport, uint32_t array_index) +{ + if (transport->steady_recorded) return 1; + if (r_vkResetCommandBuffer(transport->command_buffer, 0) != VK_SUCCESS) return 0; + VkCommandBufferBeginInfo begin = { + .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO + }; + if (r_vkBeginCommandBuffer(transport->command_buffer, &begin) != VK_SUCCESS) return 0; + + VkImageMemoryBarrier before[2] = { + { + .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, + .srcAccessMask = 0, + .dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT, + .oldLayout = VK_IMAGE_LAYOUT_UNDEFINED, + .newLayout = VK_IMAGE_LAYOUT_GENERAL, + .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, + .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, + .image = image->relay_source_image, + .subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, array_index, 1} + }, + { + .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, + .srcAccessMask = 0, + .dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT, + .oldLayout = VK_IMAGE_LAYOUT_UNDEFINED, + .newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, + .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, + .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, + .image = transport->image, + .subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1} + } + }; + r_vkCmdPipelineBarrier( + transport->command_buffer, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, + VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, NULL, 0, NULL, 2, before); + + VkImageCopy copy = { + .srcSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, array_index, 1}, + .dstSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}, + .extent = {swapchain->width, swapchain->height, 1} + }; + r_vkCmdCopyImage( + transport->command_buffer, image->relay_source_image, + VK_IMAGE_LAYOUT_GENERAL, transport->image, + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, ©); + + VkImageMemoryBarrier after = { + .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, + .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT, + .dstAccessMask = VK_ACCESS_MEMORY_READ_BIT, + .oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, + .newLayout = VK_IMAGE_LAYOUT_GENERAL, + .srcQueueFamilyIndex = relay_queue_family, + .dstQueueFamilyIndex = VK_QUEUE_FAMILY_EXTERNAL, + .image = transport->image, + .subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1} + }; + r_vkCmdPipelineBarrier( + transport->command_buffer, VK_PIPELINE_STAGE_TRANSFER_BIT, + VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, 0, NULL, 0, NULL, 1, &after); + if (r_vkEndCommandBuffer(transport->command_buffer) != VK_SUCCESS) return 0; + transport->steady_recorded = 1; + return 1; +} + +static int relay_submit(const VkCommandBuffer *commands, uint32_t command_count, int *submit_ok) +{ + *submit_ok = 0; + VkSubmitInfo submit = { + .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO, + .commandBufferCount = command_count, + .pCommandBuffers = commands + }; + if (!relay_can_export_fence) { + if (r_vkQueueSubmit(relay_queue, 1, &submit, VK_NULL_HANDLE) != VK_SUCCESS) return -1; + if (r_vkQueueWaitIdle(relay_queue) != VK_SUCCESS) return -1; + *submit_ok = 1; + return -1; + } + VkExportFenceCreateInfo export_info = { + .sType = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO, + .handleTypes = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT + }; + VkFenceCreateInfo fence_info = { + .sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, + .pNext = &export_info + }; + VkFence fence = VK_NULL_HANDLE; + if (r_vkCreateFence(relay_device, &fence_info, NULL, &fence) != VK_SUCCESS) { + if (r_vkQueueSubmit(relay_queue, 1, &submit, VK_NULL_HANDLE) != VK_SUCCESS) return -1; + if (r_vkQueueWaitIdle(relay_queue) != VK_SUCCESS) return -1; + *submit_ok = 1; + return -1; + } + if (r_vkQueueSubmit(relay_queue, 1, &submit, fence) != VK_SUCCESS) { + r_vkDestroyFence(relay_device, fence, NULL); + return -1; + } + int fd = -1; + VkFenceGetFdInfoKHR fd_info = { + .sType = VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR, + .fence = fence, + .handleType = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT + }; + if (r_vkGetFenceFdKHR(relay_device, &fd_info, &fd) != VK_SUCCESS) fd = -1; + r_vkDestroyFence(relay_device, fence, NULL); + *submit_ok = 1; + return fd; +} + +static int relay_register(uint32_t slot, uint32_t image_index, uint32_t eye) +{ + struct gn_swapchain *swapchain = &swapchains[slot]; + struct gn_image *image = &swapchain->images[image_index]; + struct gn_transport_image *transport = &image->transport[eye]; + if (swapchain->sample_count != 1) return 0; + if (!relay_init()) return 0; + if (!relay_create_source(swapchain, image)) return 0; + if (!transport->hardware_buffer && !relay_create_transport(swapchain, transport)) return 0; + if (transport->registered) return 1; + + const uint32_t transport_index = slot * GN_UNIX_MAX_IMAGES + image_index; + const int swap_red_blue = + swapchain->format == VK_FORMAT_B8G8R8A8_UNORM || + swapchain->format == VK_FORMAT_B8G8R8A8_SRGB; + char line[192], response[64] = {0}; + snprintf(line, sizeof(line), + "BUFFER eye=%u index=%u w=%u h=%u swizzle=%u\n", + eye, transport_index, swapchain->width, swapchain->height, + swap_red_blue ? 1u : 0u); + if (!transact_line(line, response, sizeof(response)) || + strncmp(response, "OK", 2) || + AHardwareBuffer_sendHandleToUnixSocket( + (AHardwareBuffer *)transport->hardware_buffer, transport_fd) != 0 || + !read_line(transport_fd, response, sizeof(response)) || + strncmp(response, "OK", 2)) { + log_line("relay: registration failed"); + close_transport(); + return 0; + } + transport->registered = 1; + { + char trace[192]; + snprintf(trace, sizeof(trace), + "relay registered eye=%u index=%u size=%ux%u swizzle=%u", + eye, transport_index, swapchain->width, swapchain->height, + swap_red_blue ? 1u : 0u); + log_line(trace); + } + return 1; +} +#endif + static void destroy_transport_image(struct gn_transport_image *transport) { +#if defined(__ANDROID__) + if (transport->relay) { + if (transport->command_buffer && relay_pool) + r_vkFreeCommandBuffers(relay_device, relay_pool, 1, &transport->command_buffer); + if (transport->image) r_vkDestroyImage(relay_device, transport->image, NULL); + if (transport->memory) r_vkFreeMemory(relay_device, transport->memory, NULL); + if (transport->hardware_buffer) + AHardwareBuffer_release((AHardwareBuffer *)transport->hardware_buffer); + memset(transport, 0, sizeof(*transport)); + return; + } +#endif if (transport->command_buffer && command_pool && p_vkFreeCommandBuffers) p_vkFreeCommandBuffers(device, command_pool, 1, &transport->command_buffer); if (transport->image && p_vkDestroyImage) @@ -1037,10 +1615,17 @@ static int record_ahardwarebuffer_copy( } #endif + static void destroy_image(struct gn_image *image) { for (uint32_t eye = 0; eye < 2; ++eye) destroy_transport_image(&image->transport[eye]); +#if defined(__ANDROID__) + if (image->relay_source_image) + r_vkDestroyImage(relay_device, image->relay_source_image, NULL); + if (image->relay_source_memory) + r_vkFreeMemory(relay_device, image->relay_source_memory, NULL); +#endif if (image->dma_buf_fd >= 0) close(image->dma_buf_fd); if (image->image && p_vkDestroyImage) p_vkDestroyImage(device, image->image, NULL); if (image->memory && p_vkFreeMemory) p_vkFreeMemory(device, image->memory, NULL); @@ -1116,8 +1701,24 @@ static int register_image(uint32_t slot, uint32_t image_index, uint32_t eye, return 1; } destroy_transport_image(&image->transport[eye]); +#if defined(__ANDROID__) + if (relay_register(slot, image_index, eye)) { + image->transport_kind[eye] = GN_TRANSPORT_RELAY; + image->registered_eye_mask |= bit; + image->registered_array_index[eye] = array_index; + return 1; + } + destroy_transport_image(&image->transport[eye]); +#endif image->transport_kind[eye] = GN_TRANSPORT_DMABUF; } + if (image->transport_kind[eye] == GN_TRANSPORT_RELAY) { + if (image->registered_array_index[eye] != array_index) { + image->transport[eye].steady_recorded = 0; + } + image->registered_array_index[eye] = array_index; + return 1; + } if (image->transport_kind[eye] == GN_TRANSPORT_AHARDWAREBUFFER) { if (image->registered_array_index[eye] != array_index) { image->transport[eye].steady_recorded = 0; @@ -1548,6 +2149,9 @@ static int submit_views( VkCommandBuffer commands[2]; struct gn_transport_image *recorded[2]; uint32_t command_count = 0; + VkCommandBuffer relay_commands[2]; + struct gn_transport_image *relay_recorded[2]; + uint32_t relay_count = 0; for (uint32_t i = 0; i < view_count; ++i) { const struct gn_unix_submit_view_args *view = &views[i]; if (!register_image(view->slot, view->image_index, view->eye, @@ -1558,6 +2162,17 @@ static int submit_views( #if defined(__ANDROID__) struct gn_image *image = &swapchains[view->slot].images[view->image_index]; + if (image->transport_kind[view->eye] == GN_TRANSPORT_RELAY) { + struct gn_transport_image *transport = &image->transport[view->eye]; + if (!relay_record_copy(&swapchains[view->slot], image, transport, + view->array_index)) { + pthread_mutex_unlock(&socket_mutex); + return 0; + } + relay_commands[relay_count] = transport->command_buffer; + relay_recorded[relay_count] = transport; + ++relay_count; + } if (image->transport_kind[view->eye] == GN_TRANSPORT_AHARDWAREBUFFER) { struct gn_transport_image *transport = &image->transport[view->eye]; if (!record_ahardwarebuffer_copy( @@ -1591,6 +2206,23 @@ static int submit_views( return 0; } for (uint32_t i = 0; i < command_count; ++i) recorded[i]->initialized = 1; +#if defined(__ANDROID__) + if (relay_count) { + // The game-queue submit above already waited for the render to finish; the relay + // copy runs after it on its own device, and its fence becomes the acquire fence. + int relay_ok = 0; + int relay_fence = relay_submit(relay_commands, relay_count, &relay_ok); + if (!relay_ok) { + if (relay_fence >= 0) close(relay_fence); + if (fence_fd >= 0) close(fence_fd); + pthread_mutex_unlock(&socket_mutex); + return 0; + } + for (uint32_t i = 0; i < relay_count; ++i) relay_recorded[i]->initialized = 1; + if (fence_fd >= 0) close(fence_fd); + fence_fd = relay_fence; + } +#endif int ok = 1; const uint64_t frame_id = ++transport_frame_id; From 7d068a8f8356935d7496b97f00fc48cbef2b92a6 Mon Sep 17 00:00:00 2001 From: Utkarsh Dalal Date: Sun, 23 Aug 2026 00:17:15 +0530 Subject: [PATCH 09/46] Try every relay driver candidate until one has the needed extensions; raise render scale to 0.65 --- .../xr/windows/WindowsVrControlServer.kt | 4 +-- .../unix/gamenative_openxr_unix.c | 35 ++++++++++++------- 2 files changed, 25 insertions(+), 14 deletions(-) diff --git a/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrControlServer.kt b/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrControlServer.kt index 999f4a9b20..55b370a7c0 100644 --- a/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrControlServer.kt +++ b/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrControlServer.kt @@ -174,8 +174,8 @@ class WindowsVrControlServer( val snapshot = currentSnapshot() ?: return "ERROR unavailable" // The recommended per-eye size is far beyond what an emulated producer can fill; // halve it (even dimensions) — quarter the pixels for render, copy, and upload. - val scaledWidth = (snapshot.timing[5] / 2) and 1L.inv() - val scaledHeight = (snapshot.timing[6] / 2) and 1L.inv() + val scaledWidth = (snapshot.timing[5] * 13 / 20) and 1L.inv() + val scaledHeight = (snapshot.timing[6] * 13 / 20) and 1L.inv() return "OK count=2 width=$scaledWidth height=$scaledHeight" } diff --git a/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c b/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c index 5a527cee91..3e23461901 100644 --- a/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c +++ b/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c @@ -842,23 +842,33 @@ static int relay_init(void) "libvulkan_freedreno.so", "libvulkan.so", NULL }; PFN_vkGetInstanceProcAddr gipa = NULL; - for (int i = 0; candidates[i] && !gipa; ++i) { - relay_lib = dlopen(candidates[i], RTLD_NOW | RTLD_LOCAL); + PFN_vkCreateInstance create_instance = NULL; + int candidate = 0; +next_candidate: + if (relay_instance) { + PFN_vkDestroyInstance destroy_instance = gipa ? + (PFN_vkDestroyInstance)gipa(relay_instance, "vkDestroyInstance") : NULL; + if (destroy_instance) destroy_instance(relay_instance, NULL); + relay_instance = VK_NULL_HANDLE; + } + if (relay_lib) { dlclose(relay_lib); relay_lib = NULL; } + gipa = NULL; + for (; candidates[candidate] && !gipa; ++candidate) { + relay_lib = dlopen(candidates[candidate], RTLD_NOW | RTLD_LOCAL); if (!relay_lib) continue; gipa = (PFN_vkGetInstanceProcAddr)dlsym(relay_lib, "vk_icdGetInstanceProcAddr"); if (!gipa) gipa = (PFN_vkGetInstanceProcAddr)dlsym(relay_lib, "vkGetInstanceProcAddr"); if (!gipa) { dlclose(relay_lib); relay_lib = NULL; continue; } { char trace[128]; - snprintf(trace, sizeof(trace), "relay: using %s", candidates[i]); + snprintf(trace, sizeof(trace), "relay: trying %s", candidates[candidate]); log_line(trace); } } if (!gipa) { log_line("relay: no usable Vulkan driver"); return 0; } - PFN_vkCreateInstance create_instance = - (PFN_vkCreateInstance)gipa(NULL, "vkCreateInstance"); - if (!create_instance) return 0; + create_instance = (PFN_vkCreateInstance)gipa(NULL, "vkCreateInstance"); + if (!create_instance) goto next_candidate; VkApplicationInfo app = { .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO, .pApplicationName = "gamenative-xr-relay", @@ -870,7 +880,7 @@ static int relay_init(void) }; if (create_instance(&instance_info, NULL, &relay_instance) != VK_SUCCESS) { log_line("relay: vkCreateInstance failed"); - return 0; + goto next_candidate; } #define RELAY_ILOAD(name) PFN_##name i_##name = (PFN_##name)gipa(relay_instance, #name) @@ -884,13 +894,13 @@ static int relay_init(void) if (!i_vkEnumeratePhysicalDevices || !i_vkGetPhysicalDeviceQueueFamilyProperties || !i_vkEnumerateDeviceExtensionProperties || !i_vkCreateDevice || !i_vkGetDeviceProcAddr || !i_vkGetPhysicalDeviceMemoryProperties) - return 0; + goto next_candidate; r_vkGetPhysicalDeviceMemoryProperties = i_vkGetPhysicalDeviceMemoryProperties; uint32_t count = 1; if (i_vkEnumeratePhysicalDevices(relay_instance, &count, &relay_phys) < 0 || !count) { log_line("relay: no physical device"); - return 0; + goto next_candidate; } VkQueueFamilyProperties families[8]; @@ -920,10 +930,11 @@ static int relay_init(void) VkExtensionProperties supported[256]; uint32_t supported_count = 256; if (i_vkEnumerateDeviceExtensionProperties(relay_phys, NULL, &supported_count, supported) < 0) - return 0; + goto next_candidate; const char *enabled[16]; uint32_t enabled_count = 0; int have_ahb = 0, have_dmabuf = 0, have_fd = 0; + relay_can_export_fence = 0; for (uint32_t w = 0; w < sizeof(wanted) / sizeof(wanted[0]); ++w) { for (uint32_t i = 0; i < supported_count; ++i) { if (strcmp(supported[i].extensionName, wanted[w]) == 0) { @@ -941,7 +952,7 @@ static int relay_init(void) snprintf(trace, sizeof(trace), "relay: missing extensions ahb=%d dmabuf=%d fd=%d", have_ahb, have_dmabuf, have_fd); log_line(trace); - return 0; + goto next_candidate; } float priority = 1.0f; @@ -960,7 +971,7 @@ static int relay_init(void) }; if (i_vkCreateDevice(relay_phys, &device_info, NULL, &relay_device) != VK_SUCCESS) { log_line("relay: vkCreateDevice failed"); - return 0; + goto next_candidate; } r_vkGetDeviceProcAddr = i_vkGetDeviceProcAddr; From 2fac1a09524b0049806aa21641d65d2edb58fabe Mon Sep 17 00:00:00 2001 From: Utkarsh Dalal Date: Sun, 23 Aug 2026 00:21:33 +0530 Subject: [PATCH 10/46] Reach past the rootfs Mesa: absolute system loader and adrenotools turnip as relay candidates --- .../unix/gamenative_openxr_unix.c | 20 ++++++++++++++++--- 1 file changed, 17 insertions(+), 3 deletions(-) diff --git a/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c b/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c index 3e23461901..5f5b6d861d 100644 --- a/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c +++ b/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c @@ -838,9 +838,23 @@ static int relay_init(void) if (relay_state) return relay_state > 0; relay_state = -1; - static const char *candidates[] = { - "libvulkan_freedreno.so", "libvulkan.so", NULL - }; + /* The Wine rootfs shadows the bare sonames with a Linux-platform Mesa that has no + * Android AHB support, so the useful candidates need absolute paths: the system + * loader, and the adrenotools turnip the game itself renders with. */ + static char adrenotools_path[512]; + const char *candidates[5]; + int candidate_count = 0; + candidates[candidate_count++] = "/system/lib64/libvulkan.so"; + { + const char *dir = getenv("ADRENOTOOLS_DRIVER_PATH"); + const char *name = getenv("ADRENOTOOLS_DRIVER_NAME"); + if (dir && name && strlen(dir) + strlen(name) + 2 < sizeof(adrenotools_path)) { + snprintf(adrenotools_path, sizeof(adrenotools_path), "%s%s", dir, name); + candidates[candidate_count++] = adrenotools_path; + } + } + candidates[candidate_count++] = "libvulkan_freedreno.so"; + candidates[candidate_count] = NULL; PFN_vkGetInstanceProcAddr gipa = NULL; PFN_vkCreateInstance create_instance = NULL; int candidate = 0; From 106a1a829c814a641766409c0aa9f32c7d03f981 Mon Sep 17 00:00:00 2001 From: Utkarsh Dalal Date: Sun, 23 Aug 2026 00:36:27 +0530 Subject: [PATCH 11/46] Open adrenotools-packaged drivers through the Android HAL module interface --- .../unix/gamenative_openxr_unix.c | 87 ++++++++++++++++++- 1 file changed, 84 insertions(+), 3 deletions(-) diff --git a/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c b/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c index 5f5b6d861d..12a0d9c47a 100644 --- a/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c +++ b/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c @@ -833,6 +833,63 @@ static int relay_find_memory_type(uint32_t type_bits, VkMemoryPropertyFlags want return -1; } +/* Minimal Android HAL vulkan module interface: adrenotools-packaged drivers export only + * HMI (HAL_MODULE_INFO_SYM); the loader entry points come from opening device "vk0". */ +struct gn_hw_module; +struct gn_hw_device; +struct gn_hw_methods { + int (*open)(const struct gn_hw_module *, const char *, struct gn_hw_device **); +}; +struct gn_hw_module { + uint32_t tag; + uint16_t module_api_version; + uint16_t hal_api_version; + const char *id; + const char *name; + const char *author; + struct gn_hw_methods *methods; + void *dso; + uint64_t reserved[24]; +}; +struct gn_hw_device { + uint32_t tag; + uint32_t version; + struct gn_hw_module *module; + uint64_t reserved[12]; + int (*close)(struct gn_hw_device *); +}; +struct gn_hwvulkan_device { + struct gn_hw_device common; + PFN_vkEnumerateInstanceExtensionProperties enumerate_instance_extensions; + PFN_vkCreateInstance create_instance; + PFN_vkGetInstanceProcAddr get_instance_proc_addr; +}; + +static PFN_vkCreateInstance relay_hal_create_instance; + +static PFN_vkGetInstanceProcAddr relay_open_hal(void *lib, const char *path) +{ + struct gn_hw_module *module = (struct gn_hw_module *)dlsym(lib, "HMI"); + struct gn_hw_device *device_handle = NULL; + if (!module || !module->methods || !module->methods->open) return NULL; + if (module->methods->open(module, "vk0", &device_handle) != 0 || !device_handle) { + char trace[640]; + snprintf(trace, sizeof(trace), "relay: HAL open failed for %s", path); + log_line(trace); + return NULL; + } + { + struct gn_hwvulkan_device *vulkan_device = + (struct gn_hwvulkan_device *)device_handle; + if (!vulkan_device->get_instance_proc_addr) return NULL; + relay_hal_create_instance = vulkan_device->create_instance; + char trace[640]; + snprintf(trace, sizeof(trace), "relay: opened %s via HAL module", path); + log_line(trace); + return vulkan_device->get_instance_proc_addr; + } +} + static int relay_init(void) { if (relay_state) return relay_state > 0; @@ -851,10 +908,17 @@ static int relay_init(void) if (dir && name && strlen(dir) + strlen(name) + 2 < sizeof(adrenotools_path)) { snprintf(adrenotools_path, sizeof(adrenotools_path), "%s%s", dir, name); candidates[candidate_count++] = adrenotools_path; + } else { + log_line("relay: adrenotools driver env not set in this process"); } } candidates[candidate_count++] = "libvulkan_freedreno.so"; candidates[candidate_count] = NULL; + for (int i = 0; i < candidate_count; ++i) { + char trace[640]; + snprintf(trace, sizeof(trace), "relay: candidate %d: %s", i, candidates[i]); + log_line(trace); + } PFN_vkGetInstanceProcAddr gipa = NULL; PFN_vkCreateInstance create_instance = NULL; int candidate = 0; @@ -869,10 +933,26 @@ static int relay_init(void) gipa = NULL; for (; candidates[candidate] && !gipa; ++candidate) { relay_lib = dlopen(candidates[candidate], RTLD_NOW | RTLD_LOCAL); - if (!relay_lib) continue; + if (!relay_lib) { + char trace[640]; + snprintf(trace, sizeof(trace), "relay: dlopen(%s) failed: %s", + candidates[candidate], dlerror()); + log_line(trace); + continue; + } + relay_hal_create_instance = NULL; gipa = (PFN_vkGetInstanceProcAddr)dlsym(relay_lib, "vk_icdGetInstanceProcAddr"); if (!gipa) gipa = (PFN_vkGetInstanceProcAddr)dlsym(relay_lib, "vkGetInstanceProcAddr"); - if (!gipa) { dlclose(relay_lib); relay_lib = NULL; continue; } + if (!gipa) gipa = relay_open_hal(relay_lib, candidates[candidate]); + if (!gipa) { + char trace[640]; + snprintf(trace, sizeof(trace), "relay: %s has no usable entry point", + candidates[candidate]); + log_line(trace); + dlclose(relay_lib); + relay_lib = NULL; + continue; + } { char trace[128]; snprintf(trace, sizeof(trace), "relay: trying %s", candidates[candidate]); @@ -881,7 +961,8 @@ static int relay_init(void) } if (!gipa) { log_line("relay: no usable Vulkan driver"); return 0; } - create_instance = (PFN_vkCreateInstance)gipa(NULL, "vkCreateInstance"); + create_instance = relay_hal_create_instance; + if (!create_instance) create_instance = (PFN_vkCreateInstance)gipa(NULL, "vkCreateInstance"); if (!create_instance) goto next_candidate; VkApplicationInfo app = { .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO, From 16d590c1ede0d5b4c3c2fbeedde46ac53f779527 Mon Sep 17 00:00:00 2001 From: Utkarsh Dalal Date: Sun, 23 Aug 2026 00:43:41 +0530 Subject: [PATCH 12/46] Ship frames from a worker thread so xrEndFrame stops draining the GPU; raise scale to 0.75 --- .../xr/windows/WindowsVrControlServer.kt | 4 +- .../unix/gamenative_openxr_unix.c | 131 +++++++++++++++++- 2 files changed, 128 insertions(+), 7 deletions(-) diff --git a/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrControlServer.kt b/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrControlServer.kt index 55b370a7c0..b595349560 100644 --- a/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrControlServer.kt +++ b/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrControlServer.kt @@ -174,8 +174,8 @@ class WindowsVrControlServer( val snapshot = currentSnapshot() ?: return "ERROR unavailable" // The recommended per-eye size is far beyond what an emulated producer can fill; // halve it (even dimensions) — quarter the pixels for render, copy, and upload. - val scaledWidth = (snapshot.timing[5] * 13 / 20) and 1L.inv() - val scaledHeight = (snapshot.timing[6] * 13 / 20) and 1L.inv() + val scaledWidth = (snapshot.timing[5] * 3 / 4) and 1L.inv() + val scaledHeight = (snapshot.timing[6] * 3 / 4) and 1L.inv() return "OK count=2 width=$scaledWidth height=$scaledHeight" } diff --git a/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c b/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c index 12a0d9c47a..3700fd021a 100644 --- a/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c +++ b/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c @@ -80,6 +80,8 @@ struct gn_swapchain { struct gn_image images[GN_UNIX_MAX_IMAGES]; }; +static void submit_worker_flush(void); + static pthread_mutex_t state_mutex = PTHREAD_MUTEX_INITIALIZER; static pthread_mutex_t socket_mutex = PTHREAD_MUTEX_INITIALIZER; static struct gn_swapchain swapchains[GN_UNIX_MAX_SWAPCHAINS]; @@ -107,6 +109,7 @@ static PFN_vkGetImageDrmFormatModifierPropertiesEXT p_vkGetImageDrmFormatModifie static PFN_vkGetMemoryFdKHR p_vkGetMemoryFdKHR; static PFN_vkCreateFence p_vkCreateFence; static PFN_vkDestroyFence p_vkDestroyFence; +static PFN_vkWaitForFences p_vkWaitForFences; static PFN_vkGetFenceFdKHR p_vkGetFenceFdKHR; static PFN_vkQueueSubmit p_vkQueueSubmit; static PFN_vkQueueWaitIdle p_vkQueueWaitIdle; @@ -436,6 +439,7 @@ static void load_vulkan_functions(void) LOAD_DEVICE(vkGetMemoryFdKHR); LOAD_DEVICE(vkCreateFence); LOAD_DEVICE(vkDestroyFence); + LOAD_DEVICE(vkWaitForFences); LOAD_DEVICE(vkGetFenceFdKHR); LOAD_DEVICE(vkQueueSubmit); LOAD_DEVICE(vkQueueWaitIdle); @@ -2111,6 +2115,7 @@ static int32_t unix_destroy_swapchain(void *opaque) args->result = GN_UNIX_ERROR_ARGUMENT; return 0; } + submit_worker_flush(); pthread_mutex_lock(&state_mutex); struct gn_swapchain *swapchain = &swapchains[args->slot]; for (uint32_t i = 0; i < swapchain->image_count; ++i) @@ -2240,7 +2245,118 @@ static int send_frame(const struct gn_unix_submit_view_args *view, int fence_fd, return ok; } -static int submit_views( + +/* Asynchronous frame shipper: xrEndFrame used to drain the game's GPU queue synchronously + * before transporting the frame, serializing the game's CPU and GPU completely. Instead, + * xrEndFrame drops a fence on the game queue and returns; this worker waits for the render + * to finish, runs the transport (relay copy + socket send), and the game overlaps its next + * frame's CPU work with the GPU. */ +struct gn_pending_submit { + struct gn_unix_submit_view_args views[2]; + uint32_t view_count; + VkFence fence; + int used; +}; + +static struct gn_pending_submit submit_ring[4]; +static uint32_t submit_ring_head, submit_ring_tail; +static pthread_mutex_t submit_mutex = PTHREAD_MUTEX_INITIALIZER; +static pthread_cond_t submit_cond = PTHREAD_COND_INITIALIZER; +static pthread_cond_t submit_space_cond = PTHREAD_COND_INITIALIZER; +static pthread_t submit_thread; +static int submit_thread_running; +static int submit_worker_busy; + +static int submit_views_transport(const struct gn_unix_submit_view_args *views, uint32_t view_count); + +static void *submit_worker(void *unused) +{ + (void)unused; + for (;;) { + struct gn_pending_submit item; + pthread_mutex_lock(&submit_mutex); + while (submit_thread_running && !submit_ring[submit_ring_tail].used) + pthread_cond_wait(&submit_cond, &submit_mutex); + if (!submit_thread_running) { + pthread_mutex_unlock(&submit_mutex); + return NULL; + } + item = submit_ring[submit_ring_tail]; + submit_ring[submit_ring_tail].used = 0; + submit_ring_tail = (submit_ring_tail + 1) % 4; + submit_worker_busy = 1; + pthread_cond_signal(&submit_space_cond); + pthread_mutex_unlock(&submit_mutex); + + if (item.fence != VK_NULL_HANDLE) { + p_vkWaitForFences(device, 1, &item.fence, VK_TRUE, UINT64_MAX); + p_vkDestroyFence(device, item.fence, NULL); + } + if (!submit_views_transport(item.views, item.view_count)) { + static int failure_logged; + if (!failure_logged) { + failure_logged = 1; + log_line("async transport failed; later frames may recover"); + } + } + pthread_mutex_lock(&submit_mutex); + submit_worker_busy = 0; + pthread_cond_signal(&submit_space_cond); + pthread_mutex_unlock(&submit_mutex); + } +} + +static void submit_worker_flush(void) +{ + pthread_mutex_lock(&submit_mutex); + while (submit_thread_running && + (submit_ring[submit_ring_tail].used || submit_worker_busy)) + pthread_cond_wait(&submit_space_cond, &submit_mutex); + pthread_mutex_unlock(&submit_mutex); +} + +static int submit_views_async(const struct gn_unix_submit_view_args *views, uint32_t view_count) +{ + if (!p_vkWaitForFences || !p_vkCreateFence || !p_vkDestroyFence || !p_vkQueueSubmit) + return submit_views_transport(views, view_count); + + pthread_mutex_lock(&submit_mutex); + if (!submit_thread_running) { + submit_thread_running = 1; + if (pthread_create(&submit_thread, NULL, submit_worker, NULL) != 0) { + submit_thread_running = 0; + pthread_mutex_unlock(&submit_mutex); + return submit_views_transport(views, view_count); + } + log_line("async frame shipper started"); + } + pthread_mutex_unlock(&submit_mutex); + + VkFence fence = VK_NULL_HANDLE; + VkFenceCreateInfo fence_info = {.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO}; + if (p_vkCreateFence(device, &fence_info, NULL, &fence) == VK_SUCCESS) { + VkSubmitInfo marker = {.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO}; + if (p_vkQueueSubmit(queue, 1, &marker, fence) != VK_SUCCESS) { + p_vkDestroyFence(device, fence, NULL); + fence = VK_NULL_HANDLE; + } + } + + pthread_mutex_lock(&submit_mutex); + while (submit_ring[submit_ring_head].used) + pthread_cond_wait(&submit_space_cond, &submit_mutex); + struct gn_pending_submit *slot = &submit_ring[submit_ring_head]; + for (uint32_t i = 0; i < view_count; ++i) slot->views[i] = views[i]; + slot->view_count = view_count; + slot->fence = fence; + slot->used = 1; + submit_ring_head = (submit_ring_head + 1) % 4; + pthread_cond_signal(&submit_cond); + pthread_mutex_unlock(&submit_mutex); + return 1; +} + +static int submit_views_transport( const struct gn_unix_submit_view_args *views, uint32_t view_count) { if (!view_count || view_count > 2) return 0; @@ -2304,8 +2420,13 @@ static int submit_views( } int submit_ok = 0; - int fence_fd = submit_and_make_acquire_fence_fd( - commands, command_count, &submit_ok); + int fence_fd = -1; + if (command_count == 0) { + submit_ok = 1; + } else { + fence_fd = submit_and_make_acquire_fence_fd( + commands, command_count, &submit_ok); + } if (!submit_ok) { if (fence_fd >= 0) close(fence_fd); pthread_mutex_unlock(&socket_mutex); @@ -2348,7 +2469,7 @@ static int submit_views( static int32_t unix_submit_image(void *opaque) { struct gn_unix_submit_image_args *args = opaque; - args->result = submit_views( + args->result = submit_views_async( (const struct gn_unix_submit_view_args *)args, 1) ? GN_UNIX_SUCCESS : GN_UNIX_ERROR_TRANSPORT; return 0; @@ -2361,7 +2482,7 @@ static int32_t unix_submit_stereo(void *opaque) args->result = GN_UNIX_ERROR_ARGUMENT; return 0; } - args->result = submit_views(args->views, args->view_count) ? + args->result = submit_views_async(args->views, args->view_count) ? GN_UNIX_SUCCESS : GN_UNIX_ERROR_TRANSPORT; return 0; } From 3a13461a2078a81f6cd680a7f0a9839292c4622e Mon Sep 17 00:00:00 2001 From: Utkarsh Dalal Date: Sun, 23 Aug 2026 01:04:35 +0530 Subject: [PATCH 13/46] Route the control plane through the unixbridge: winsock's 40ms wineserver round trip becomes a bionic socket --- .../xr/windows/WindowsVrControlServer.kt | 21 +++ .../gamenative_openxr_runtime.c | 145 ++++++++++++++++-- .../openxr_runtime/gamenative_openxr_unix.h | 8 + .../windows/openxr_runtime/kernel32_x64.def | 1 + .../windows/openxr_runtime/kernel32_x86.def | 1 + .../unix/gamenative_openxr_unix.c | 127 ++++++++++++++- 6 files changed, 290 insertions(+), 13 deletions(-) diff --git a/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrControlServer.kt b/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrControlServer.kt index b595349560..5f6733cf6d 100644 --- a/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrControlServer.kt +++ b/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrControlServer.kt @@ -144,9 +144,30 @@ class WindowsVrControlServer( /** One round-trip for the whole per-frame state: frame timing, view poses, and both * hands' input as four lines. Saves three guest-side TCP round trips every frame. */ + private var frameCount = 0 + private var frameCountStartMs = 0L + + private var handlerMs = 0L + private fun frameSync(): String { + val handlerStart = System.nanoTime() val frame = waitFrame() if (!frame.startsWith("OK")) return frame + handlerMs += (System.nanoTime() - handlerStart) / 1_000_000 + val now = System.currentTimeMillis() + if (frameCountStartMs == 0L) frameCountStartMs = now + frameCount++ + if (now - frameCountStartMs >= 5000) { + val fps = frameCount * 1000f / (now - frameCountStartMs) + timber.log.Timber.i( + "Windows VR game frame rate: %.1f fps (server wait avg %.1f ms)", + fps, + handlerMs.toFloat() / frameCount, + ) + frameCount = 0 + handlerMs = 0 + frameCountStartMs = now + } return frame + "\n" + locateViews() + "\n" + getInput(listOf("GET_INPUT", "hand=0")) + "\n" + getInput(listOf("GET_INPUT", "hand=1")) diff --git a/app/src/main/windows/openxr_runtime/gamenative_openxr_runtime.c b/app/src/main/windows/openxr_runtime/gamenative_openxr_runtime.c index f6928a4c0a..e5d7a75cef 100644 --- a/app/src/main/windows/openxr_runtime/gamenative_openxr_runtime.c +++ b/app/src/main/windows/openxr_runtime/gamenative_openxr_runtime.c @@ -1201,19 +1201,38 @@ static int gn_bridge_call_locked(const char* command, char* response, gn_size re return gn_starts_with(out, "OK"); } -static int gn_bridge_call(const char* command, char* response, gn_size response_size) { - int ok; - gn_lock_acquire(); - ok = gn_bridge_call_locked(command, response, response_size); - gn_lock_release(); - return ok; +static int gn_unix_control_state; /* 0 untried, 1 works, -1 unavailable */ + +static int gn_unix_control_transact(const char* command, gn_uint32 lines, + char* response, gn_size response_size) { + struct gn_unix_control_transact_args args; + gn_size len = 0; + if (gn_unix_control_state < 0) return 0; + while (command[len] && len + 1 < sizeof(args.request)) { + args.request[len] = command[len]; + ++len; + } + if (command[len]) return 0; + args.request[len] = 0; + args.response[0] = 0; + args.response_lines = lines; + args.result = GN_UNIX_ERROR_UNAVAILABLE; + if (!gn_unix_call(GN_UNIX_CONTROL_TRANSACT, &args) || + args.result != GN_UNIX_SUCCESS) { + if (gn_unix_control_state == 0) { + gn_unix_control_state = -1; + gn_log_line("unix control fast path unavailable; staying on winsock"); + } + return 0; + } + if (gn_unix_control_state == 0) { + gn_unix_control_state = 1; + gn_log_line("unix control fast path active"); + } + gn_copy(response, response_size, args.response); + return 1; } -static char gn_cached_views[512]; -static char gn_cached_input[2][512]; -static int gn_cache_valid = 0; -static int gn_frame_sync_supported = 1; - static int gn_bridge_read_line_locked(char* out, gn_size out_size) { gn_size offset = 0; char ch = 0; @@ -1229,10 +1248,104 @@ static int gn_bridge_read_line_locked(char* out, gn_size out_size) { return gn_starts_with(out, "OK"); } + +static int gn_bridge_call(const char* command, char* response, gn_size response_size) { + int ok; + char local[512]; + gn_lock_acquire(); + if (gn_unix_control_state >= 0 && + gn_unix_control_transact(command, 1, local, sizeof(local))) { + if (response && response_size) gn_copy(response, response_size, local); + ok = gn_starts_with(local, "OK"); + gn_lock_release(); + return ok; + } + ok = gn_bridge_call_locked(command, response, response_size); + gn_lock_release(); + return ok; +} + +#ifdef _WIN64 +unsigned long long GetTickCount64(void); +#else +unsigned long long __stdcall GetTickCount64(void); +#endif + +/* Frame-phase timing: where does each frame's wall time go. Logged every 64 frames. */ +static unsigned long long gn_phase_ms[6]; /* waitFrame, dxvkLock, transport, acquire, other, total */ +static unsigned long long gn_phase_last_frame_start; +static unsigned int gn_phase_frames; + +static void gn_phase_account(int phase, unsigned long long elapsed) { + gn_phase_ms[phase] += elapsed; +} + +static void gn_phase_frame_tick(unsigned long long now) { + if (gn_phase_last_frame_start) { + gn_phase_ms[5] += now - gn_phase_last_frame_start; + if (++gn_phase_frames == 64) { + char line[224]; + gn_size n = gn_append(line, sizeof(line), 0, "phase avg ms: wait="); + n = gn_append_i64(line, sizeof(line), n, (long long)(gn_phase_ms[0] / 64)); + n = gn_append(line, sizeof(line), n, " dxvkLock="); + n = gn_append_i64(line, sizeof(line), n, (long long)(gn_phase_ms[1] / 64)); + n = gn_append(line, sizeof(line), n, " transport="); + n = gn_append_i64(line, sizeof(line), n, (long long)(gn_phase_ms[2] / 64)); + n = gn_append(line, sizeof(line), n, " acquire="); + n = gn_append_i64(line, sizeof(line), n, (long long)(gn_phase_ms[3] / 64)); + n = gn_append(line, sizeof(line), n, " frame="); + n = gn_append_i64(line, sizeof(line), n, (long long)(gn_phase_ms[5] / 64)); + gn_log_line(line); + for (int i = 0; i < 6; ++i) gn_phase_ms[i] = 0; + gn_phase_frames = 0; + } + } + gn_phase_last_frame_start = now; +} + +static char gn_cached_views[512]; +static char gn_cached_input[2][512]; +static int gn_cache_valid = 0; +static int gn_frame_sync_supported = 1; +static int gn_split_line(const char** cursor, char* out, gn_size out_size) { + const char* p = *cursor; + gn_size n = 0; + if (!*p) return 0; + while (*p && *p != '\n' && n + 1 < out_size) out[n++] = *p++; + out[n] = 0; + if (*p == '\n') ++p; + *cursor = p; + return 1; +} + static int gn_bridge_frame_sync(char* frame_out, gn_size frame_size) { int ok; gn_lock_acquire(); gn_cache_valid = 0; + if (gn_unix_control_state >= 0) { + char bundle[896]; + if (gn_unix_control_transact("FRAME_SYNC", 4, bundle, sizeof(bundle))) { + const char* cursor = bundle; + char first[192]; + if (gn_split_line(&cursor, first, sizeof(first)) && + gn_starts_with(first, "OK")) { + gn_copy(frame_out, frame_size, first); + ok = gn_split_line(&cursor, gn_cached_views, sizeof(gn_cached_views)) && + gn_split_line(&cursor, gn_cached_input[0], sizeof(gn_cached_input[0])) && + gn_split_line(&cursor, gn_cached_input[1], sizeof(gn_cached_input[1])); + gn_cache_valid = ok; + gn_lock_release(); + return ok; + } + gn_copy(frame_out, frame_size, first); + if (gn_starts_with(first, "ERROR")) { + gn_frame_sync_supported = 0; + gn_log_line("FRAME_SYNC unsupported by bridge; using separate per-frame requests"); + } + gn_lock_release(); + return 0; + } + } ok = gn_bridge_call_locked("FRAME_SYNC", frame_out, frame_size); if (ok) { ok = gn_bridge_read_line_locked(gn_cached_views, sizeof(gn_cached_views)) && @@ -2235,7 +2348,10 @@ static XrResult XRAPI_CALL gn_xrWaitFrame(XrSession session, const XrFrameWaitIn (void)waitInfo; char response[160]; int synced; + unsigned long long phase_start; if (session != gn_session || !frameState) return XR_ERROR_HANDLE_INVALID; + phase_start = GetTickCount64(); + gn_phase_frame_tick(phase_start); synced = gn_frame_sync_supported && gn_bridge_frame_sync(response, sizeof(response)); if (!synced && !gn_frame_sync_supported) synced = gn_bridge_call("WAIT_FRAME", response, sizeof(response)); @@ -2244,6 +2360,7 @@ static XrResult XRAPI_CALL gn_xrWaitFrame(XrSession session, const XrFrameWaitIn frameState->predictedDisplayPeriod = gn_parse_i64(response, "period", 11111111); frameState->shouldRender = gn_parse_i64(response, "render", gn_session_running ? 1 : 0) != 0 ? XR_TRUE : XR_FALSE; gn_next_display_time = frameState->predictedDisplayTime + frameState->predictedDisplayPeriod; + gn_phase_account(0, GetTickCount64() - phase_start); long long quest_state = gn_parse_i64(response, "state", 0); if (quest_state == XR_SESSION_STATE_LOSS_PENDING) { @@ -2312,8 +2429,11 @@ static XrResult XRAPI_CALL gn_xrEndFrame(XrSession session, const XrFrameEndInfo } int submission_failed = 0; + unsigned long long phase_start = GetTickCount64(); if (gn_gfx_api == GN_GFX_D3D11) gn_dxvk_flush_and_lock(); if (gn_gfx_api == GN_GFX_D3D12) gn_vkd3d_lock(); + gn_phase_account(1, GetTickCount64() - phase_start); + phase_start = GetTickCount64(); for (gn_uint32 layer_index = 0; layer_index < frameEndInfo->layerCount; ++layer_index) { const XrCompositionLayerBaseHeader* base = @@ -2409,6 +2529,7 @@ static XrResult XRAPI_CALL gn_xrEndFrame(XrSession session, const XrFrameEndInfo gn_swapchains[i].last_released_valid = 0; if (gn_gfx_api == GN_GFX_D3D11) gn_dxvk_unlock(); if (gn_gfx_api == GN_GFX_D3D12) gn_vkd3d_unlock(); + gn_phase_account(2, GetTickCount64() - phase_start); @@ -2926,11 +3047,13 @@ static XrResult XRAPI_CALL gn_xrWaitSwapchainImage(XrSwapchain swapchain, const } if (state->submitted[index]) { struct gn_unix_acquire_image_args args; + unsigned long long phase_start = GetTickCount64(); args.slot = (gn_u32)slot; args.image_index = index; args.timeout_ns = waitInfo->timeout; args.result = GN_UNIX_ERROR_UNAVAILABLE; if (!gn_unix_call(GN_UNIX_ACQUIRE_IMAGE, &args)) return XR_ERROR_RUNTIME_FAILURE; + gn_phase_account(3, GetTickCount64() - phase_start); if (args.result == GN_UNIX_ERROR_TIMEOUT) return XR_TIMEOUT_EXPIRED; if (args.result != GN_UNIX_SUCCESS) return XR_ERROR_RUNTIME_FAILURE; state->submitted[index] = 0; diff --git a/app/src/main/windows/openxr_runtime/gamenative_openxr_unix.h b/app/src/main/windows/openxr_runtime/gamenative_openxr_unix.h index d3b4bcd627..79e937e618 100644 --- a/app/src/main/windows/openxr_runtime/gamenative_openxr_unix.h +++ b/app/src/main/windows/openxr_runtime/gamenative_openxr_unix.h @@ -28,6 +28,7 @@ enum gn_unix_call_code { GN_UNIX_ACQUIRE_IMAGE, GN_UNIX_SUBMIT_IMAGE, GN_UNIX_SUBMIT_STEREO, + GN_UNIX_CONTROL_TRANSACT, GN_UNIX_CALL_COUNT }; @@ -122,6 +123,13 @@ struct gn_unix_submit_image_args { gn_i32 result; }; +struct gn_unix_control_transact_args { + char request[192]; + char response[896]; + gn_u32 response_lines; + gn_i32 result; +}; + struct gn_unix_submit_stereo_args { gn_u32 view_count; struct gn_unix_submit_view_args views[2]; diff --git a/app/src/main/windows/openxr_runtime/kernel32_x64.def b/app/src/main/windows/openxr_runtime/kernel32_x64.def index 58e6fe5a9f..cced63522e 100644 --- a/app/src/main/windows/openxr_runtime/kernel32_x64.def +++ b/app/src/main/windows/openxr_runtime/kernel32_x64.def @@ -10,3 +10,4 @@ EXPORTS GetLastError FreeLibrary ExitProcess + GetTickCount64 diff --git a/app/src/main/windows/openxr_runtime/kernel32_x86.def b/app/src/main/windows/openxr_runtime/kernel32_x86.def index 2c8a5e5188..0d1cef62df 100644 --- a/app/src/main/windows/openxr_runtime/kernel32_x86.def +++ b/app/src/main/windows/openxr_runtime/kernel32_x86.def @@ -10,3 +10,4 @@ EXPORTS GetLastError@0 FreeLibrary@4 ExitProcess@4 + GetTickCount64 diff --git a/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c b/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c index 3700fd021a..5a16a2b606 100644 --- a/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c +++ b/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c @@ -17,6 +17,9 @@ #include #include #include +#include +#include +#include #include #include #include @@ -2475,6 +2478,124 @@ static int32_t unix_submit_image(void *opaque) return 0; } + +/* Control-plane fast path: the PE runtime's winsock round trip to the Kotlin control + * server costs ~40ms under Wine+FEX because blocking recv detours through wineserver. + * The same request over a plain bionic socket from the unix side is sub-millisecond. */ +static int control_fast_fd = -1; +static pthread_mutex_t control_fast_mutex = PTHREAD_MUTEX_INITIALIZER; +static char control_fast_buf[1024]; +static uint32_t control_fast_len, control_fast_off; + +static void control_fast_close(void) +{ + if (control_fast_fd >= 0) close(control_fast_fd); + control_fast_fd = -1; + control_fast_len = 0; + control_fast_off = 0; +} + +static int control_fast_read_byte(char *value) +{ + if (control_fast_off >= control_fast_len) { + ssize_t got = recv(control_fast_fd, control_fast_buf, sizeof(control_fast_buf), 0); + if (got <= 0) return 0; + control_fast_len = (uint32_t)got; + control_fast_off = 0; + } + *value = control_fast_buf[control_fast_off++]; + return 1; +} + +static int control_fast_read_line(char *out, size_t out_size) +{ + size_t offset = 0; + char value = 0; + while (offset + 1 < out_size) { + if (!control_fast_read_byte(&value)) return 0; + if (value == '\n') break; + out[offset++] = value; + } + out[offset] = 0; + return 1; +} + +static int control_fast_connect(void) +{ + if (control_fast_fd >= 0) return 1; + const char *port_text = getenv("GAMENATIVE_XR_BRIDGE_PORT"); + int port = port_text ? atoi(port_text) : 38476; + if (port <= 0) port = 38476; + int fd = socket(AF_INET, SOCK_STREAM, 0); + if (fd < 0) return 0; + int nodelay = 1; + setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &nodelay, sizeof(nodelay)); + struct sockaddr_in address; + memset(&address, 0, sizeof(address)); + address.sin_family = AF_INET; + address.sin_port = htons((uint16_t)port); + address.sin_addr.s_addr = htonl(0x7f000001); + if (connect(fd, (struct sockaddr *)&address, sizeof(address)) != 0) { + close(fd); + return 0; + } + control_fast_fd = fd; + control_fast_len = 0; + control_fast_off = 0; + char line[128]; + if (!write_all(fd, "HELLO\n", 6) || + !control_fast_read_line(line, sizeof(line)) || + strncmp(line, "OK", 2) != 0) { + control_fast_close(); + return 0; + } + log_line("unix control fast path connected"); + return 1; +} + +static int32_t unix_control_transact(void *opaque) +{ + struct gn_unix_control_transact_args *args = opaque; + args->request[sizeof(args->request) - 1] = 0; + uint32_t lines = args->response_lines ? args->response_lines : 1; + if (lines > 8) lines = 8; + args->result = GN_UNIX_ERROR_TRANSPORT; + pthread_mutex_lock(&control_fast_mutex); + if (!control_fast_connect()) { + pthread_mutex_unlock(&control_fast_mutex); + return 0; + } + size_t request_length = strlen(args->request); + args->request[request_length] = '\n'; + int sent = write_all(control_fast_fd, args->request, request_length + 1); + args->request[request_length] = 0; + if (!sent) { + control_fast_close(); + pthread_mutex_unlock(&control_fast_mutex); + return 0; + } + size_t offset = 0; + for (uint32_t i = 0; i < lines; ++i) { + char line[512]; + if (!control_fast_read_line(line, sizeof(line))) { + control_fast_close(); + pthread_mutex_unlock(&control_fast_mutex); + return 0; + } + size_t line_length = strlen(line); + if (offset + line_length + 2 > sizeof(args->response)) break; + if (i) args->response[offset++] = '\n'; + memcpy(args->response + offset, line, line_length); + offset += line_length; + /* single-line commands whose reply is an error carry no continuation lines */ + if (i == 0 && strncmp(line, "OK", 2) != 0) break; + } + args->response[offset] = 0; + args->result = GN_UNIX_SUCCESS; + pthread_mutex_unlock(&control_fast_mutex); + return 0; +} + static int32_t unix_submit_stereo(void *opaque) { struct gn_unix_submit_stereo_args *args = opaque; @@ -2495,7 +2616,8 @@ const unixlib_entry_t __wine_unix_call_funcs[GN_UNIX_CALL_COUNT] = { unix_destroy_swapchain, unix_acquire_image, unix_submit_image, - unix_submit_stereo + unix_submit_stereo, + unix_control_transact }; @@ -2508,7 +2630,8 @@ const unixlib_entry_t __wine_unix_call_wow64_funcs[GN_UNIX_CALL_COUNT] = { unix_destroy_swapchain, unix_acquire_image, unix_submit_image, - unix_submit_stereo + unix_submit_stereo, + unix_control_transact }; __attribute__((destructor)) From 568b9e48adc68c9d6cb14edf1eb786c57eee09a6 Mon Sep 17 00:00:00 2001 From: Utkarsh Dalal Date: Sun, 23 Aug 2026 01:10:43 +0530 Subject: [PATCH 14/46] Keep the unix fast path retrying through transient refusals; raise the client cap --- .../ui/screen/xr/windows/WindowsVrControlServer.kt | 2 +- .../windows/openxr_runtime/gamenative_openxr_runtime.c | 7 +++++-- 2 files changed, 6 insertions(+), 3 deletions(-) diff --git a/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrControlServer.kt b/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrControlServer.kt index 5f6733cf6d..372642387c 100644 --- a/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrControlServer.kt +++ b/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrControlServer.kt @@ -17,7 +17,7 @@ class WindowsVrControlServer( private val snapshots: WindowsVrSnapshotProvider, ) : Closeable { private val running = AtomicBoolean(false) - private val clients = Semaphore(4) + private val clients = Semaphore(16) private val executor = Executors.newFixedThreadPool(5) private var serverSocket: ServerSocket? = null private var lastFrameSerial = 0L diff --git a/app/src/main/windows/openxr_runtime/gamenative_openxr_runtime.c b/app/src/main/windows/openxr_runtime/gamenative_openxr_runtime.c index e5d7a75cef..669a6ed92a 100644 --- a/app/src/main/windows/openxr_runtime/gamenative_openxr_runtime.c +++ b/app/src/main/windows/openxr_runtime/gamenative_openxr_runtime.c @@ -1219,13 +1219,16 @@ static int gn_unix_control_transact(const char* command, gn_uint32 lines, args.result = GN_UNIX_ERROR_UNAVAILABLE; if (!gn_unix_call(GN_UNIX_CONTROL_TRANSACT, &args) || args.result != GN_UNIX_SUCCESS) { - if (gn_unix_control_state == 0) { + /* Transient failures (the server may briefly refuse connections while stale + * clients age out) must not disable the fast path forever. */ + static int consecutive_failures; + if (++consecutive_failures >= 300 && gn_unix_control_state <= 0) { gn_unix_control_state = -1; gn_log_line("unix control fast path unavailable; staying on winsock"); } return 0; } - if (gn_unix_control_state == 0) { + if (gn_unix_control_state <= 0) { gn_unix_control_state = 1; gn_log_line("unix control fast path active"); } From 3961d5d83254d81b617094c0d09c19c24c850054 Mon Sep 17 00:00:00 2001 From: Utkarsh Dalal Date: Sun, 23 Aug 2026 01:18:35 +0530 Subject: [PATCH 15/46] Block image reuse until the relay copy has executed --- .../unix/gamenative_openxr_unix.c | 28 ++++++++++++++++--- 1 file changed, 24 insertions(+), 4 deletions(-) diff --git a/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c b/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c index 5a16a2b606..2dd227cf71 100644 --- a/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c +++ b/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c @@ -84,6 +84,9 @@ struct gn_swapchain { }; static void submit_worker_flush(void); +static uint8_t image_copy_busy[32u][4u]; +static pthread_mutex_t submit_mutex = PTHREAD_MUTEX_INITIALIZER; +static pthread_cond_t submit_space_cond = PTHREAD_COND_INITIALIZER; static pthread_mutex_t state_mutex = PTHREAD_MUTEX_INITIALIZER; static pthread_mutex_t socket_mutex = PTHREAD_MUTEX_INITIALIZER; @@ -2137,6 +2140,11 @@ static int32_t unix_acquire_image(void *opaque) args->result = GN_UNIX_ERROR_ARGUMENT; return 0; } + pthread_mutex_lock(&submit_mutex); + while (image_copy_busy[args->slot][args->image_index]) + pthread_cond_wait(&submit_space_cond, &submit_mutex); + pthread_mutex_unlock(&submit_mutex); + pthread_mutex_lock(&socket_mutex); char line[512], response[64] = {0}; snprintf(line, sizeof(line), "ACQUIRE eye=0 index=%u\n", args->image_index); @@ -2263,9 +2271,7 @@ struct gn_pending_submit { static struct gn_pending_submit submit_ring[4]; static uint32_t submit_ring_head, submit_ring_tail; -static pthread_mutex_t submit_mutex = PTHREAD_MUTEX_INITIALIZER; static pthread_cond_t submit_cond = PTHREAD_COND_INITIALIZER; -static pthread_cond_t submit_space_cond = PTHREAD_COND_INITIALIZER; static pthread_t submit_thread; static int submit_thread_running; static int submit_worker_busy; @@ -2302,9 +2308,18 @@ static void *submit_worker(void *unused) log_line("async transport failed; later frames may recover"); } } + /* The relay copy reads the source image on its own queue; the game must not + * re-render into that image until the copy has actually executed. */ + if (relay_state > 0 && r_vkQueueWaitIdle) r_vkQueueWaitIdle(relay_queue); pthread_mutex_lock(&submit_mutex); + for (uint32_t i = 0; i < item.view_count; ++i) { + if (item.views[i].slot < GN_UNIX_MAX_SWAPCHAINS && + item.views[i].image_index < GN_UNIX_MAX_IMAGES && + image_copy_busy[item.views[i].slot][item.views[i].image_index]) + --image_copy_busy[item.views[i].slot][item.views[i].image_index]; + } submit_worker_busy = 0; - pthread_cond_signal(&submit_space_cond); + pthread_cond_broadcast(&submit_space_cond); pthread_mutex_unlock(&submit_mutex); } } @@ -2349,7 +2364,12 @@ static int submit_views_async(const struct gn_unix_submit_view_args *views, uint while (submit_ring[submit_ring_head].used) pthread_cond_wait(&submit_space_cond, &submit_mutex); struct gn_pending_submit *slot = &submit_ring[submit_ring_head]; - for (uint32_t i = 0; i < view_count; ++i) slot->views[i] = views[i]; + for (uint32_t i = 0; i < view_count; ++i) { + slot->views[i] = views[i]; + if (views[i].slot < GN_UNIX_MAX_SWAPCHAINS && + views[i].image_index < GN_UNIX_MAX_IMAGES) + ++image_copy_busy[views[i].slot][views[i].image_index]; + } slot->view_count = view_count; slot->fence = fence; slot->used = 1; From eef0e1f277fb2f506926f4ec6b6b4ccc12f1c549 Mon Sep 17 00:00:00 2001 From: Utkarsh Dalal Date: Sun, 23 Aug 2026 01:32:30 +0530 Subject: [PATCH 16/46] Quad-buffer the eye swapchains so acquire stops stalling the frame loop --- .../main/windows/openxr_runtime/unix/gamenative_openxr_unix.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c b/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c index 2dd227cf71..5ebc6afff9 100644 --- a/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c +++ b/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c @@ -2089,7 +2089,7 @@ static int32_t unix_create_swapchain(void *opaque) swapchain->sample_count = args->sample_count ? args->sample_count : 1; - swapchain->image_count = 3; + swapchain->image_count = 4; int optimal = 0; #if defined(__ANDROID__) optimal = swapchain->sample_count == 1 && ahb_transport_probe(); From b4a3039e5fa44d9a96d91a0d9758ccaec30be540 Mon Sep 17 00:00:00 2001 From: Utkarsh Dalal Date: Sun, 23 Aug 2026 11:03:04 +0530 Subject: [PATCH 17/46] Strip frame-phase instrumentation; raise render scale to 0.85 --- .../xr/windows/WindowsVrControlServer.kt | 4 +- .../gamenative_openxr_runtime.c | 48 ------------------- 2 files changed, 2 insertions(+), 50 deletions(-) diff --git a/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrControlServer.kt b/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrControlServer.kt index 372642387c..cae711d77c 100644 --- a/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrControlServer.kt +++ b/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrControlServer.kt @@ -195,8 +195,8 @@ class WindowsVrControlServer( val snapshot = currentSnapshot() ?: return "ERROR unavailable" // The recommended per-eye size is far beyond what an emulated producer can fill; // halve it (even dimensions) — quarter the pixels for render, copy, and upload. - val scaledWidth = (snapshot.timing[5] * 3 / 4) and 1L.inv() - val scaledHeight = (snapshot.timing[6] * 3 / 4) and 1L.inv() + val scaledWidth = (snapshot.timing[5] * 17 / 20) and 1L.inv() + val scaledHeight = (snapshot.timing[6] * 17 / 20) and 1L.inv() return "OK count=2 width=$scaledWidth height=$scaledHeight" } diff --git a/app/src/main/windows/openxr_runtime/gamenative_openxr_runtime.c b/app/src/main/windows/openxr_runtime/gamenative_openxr_runtime.c index 669a6ed92a..a836ee55c3 100644 --- a/app/src/main/windows/openxr_runtime/gamenative_openxr_runtime.c +++ b/app/src/main/windows/openxr_runtime/gamenative_openxr_runtime.c @@ -1268,44 +1268,6 @@ static int gn_bridge_call(const char* command, char* response, gn_size response_ return ok; } -#ifdef _WIN64 -unsigned long long GetTickCount64(void); -#else -unsigned long long __stdcall GetTickCount64(void); -#endif - -/* Frame-phase timing: where does each frame's wall time go. Logged every 64 frames. */ -static unsigned long long gn_phase_ms[6]; /* waitFrame, dxvkLock, transport, acquire, other, total */ -static unsigned long long gn_phase_last_frame_start; -static unsigned int gn_phase_frames; - -static void gn_phase_account(int phase, unsigned long long elapsed) { - gn_phase_ms[phase] += elapsed; -} - -static void gn_phase_frame_tick(unsigned long long now) { - if (gn_phase_last_frame_start) { - gn_phase_ms[5] += now - gn_phase_last_frame_start; - if (++gn_phase_frames == 64) { - char line[224]; - gn_size n = gn_append(line, sizeof(line), 0, "phase avg ms: wait="); - n = gn_append_i64(line, sizeof(line), n, (long long)(gn_phase_ms[0] / 64)); - n = gn_append(line, sizeof(line), n, " dxvkLock="); - n = gn_append_i64(line, sizeof(line), n, (long long)(gn_phase_ms[1] / 64)); - n = gn_append(line, sizeof(line), n, " transport="); - n = gn_append_i64(line, sizeof(line), n, (long long)(gn_phase_ms[2] / 64)); - n = gn_append(line, sizeof(line), n, " acquire="); - n = gn_append_i64(line, sizeof(line), n, (long long)(gn_phase_ms[3] / 64)); - n = gn_append(line, sizeof(line), n, " frame="); - n = gn_append_i64(line, sizeof(line), n, (long long)(gn_phase_ms[5] / 64)); - gn_log_line(line); - for (int i = 0; i < 6; ++i) gn_phase_ms[i] = 0; - gn_phase_frames = 0; - } - } - gn_phase_last_frame_start = now; -} - static char gn_cached_views[512]; static char gn_cached_input[2][512]; static int gn_cache_valid = 0; @@ -2351,10 +2313,7 @@ static XrResult XRAPI_CALL gn_xrWaitFrame(XrSession session, const XrFrameWaitIn (void)waitInfo; char response[160]; int synced; - unsigned long long phase_start; if (session != gn_session || !frameState) return XR_ERROR_HANDLE_INVALID; - phase_start = GetTickCount64(); - gn_phase_frame_tick(phase_start); synced = gn_frame_sync_supported && gn_bridge_frame_sync(response, sizeof(response)); if (!synced && !gn_frame_sync_supported) synced = gn_bridge_call("WAIT_FRAME", response, sizeof(response)); @@ -2363,7 +2322,6 @@ static XrResult XRAPI_CALL gn_xrWaitFrame(XrSession session, const XrFrameWaitIn frameState->predictedDisplayPeriod = gn_parse_i64(response, "period", 11111111); frameState->shouldRender = gn_parse_i64(response, "render", gn_session_running ? 1 : 0) != 0 ? XR_TRUE : XR_FALSE; gn_next_display_time = frameState->predictedDisplayTime + frameState->predictedDisplayPeriod; - gn_phase_account(0, GetTickCount64() - phase_start); long long quest_state = gn_parse_i64(response, "state", 0); if (quest_state == XR_SESSION_STATE_LOSS_PENDING) { @@ -2432,11 +2390,8 @@ static XrResult XRAPI_CALL gn_xrEndFrame(XrSession session, const XrFrameEndInfo } int submission_failed = 0; - unsigned long long phase_start = GetTickCount64(); if (gn_gfx_api == GN_GFX_D3D11) gn_dxvk_flush_and_lock(); if (gn_gfx_api == GN_GFX_D3D12) gn_vkd3d_lock(); - gn_phase_account(1, GetTickCount64() - phase_start); - phase_start = GetTickCount64(); for (gn_uint32 layer_index = 0; layer_index < frameEndInfo->layerCount; ++layer_index) { const XrCompositionLayerBaseHeader* base = @@ -2532,7 +2487,6 @@ static XrResult XRAPI_CALL gn_xrEndFrame(XrSession session, const XrFrameEndInfo gn_swapchains[i].last_released_valid = 0; if (gn_gfx_api == GN_GFX_D3D11) gn_dxvk_unlock(); if (gn_gfx_api == GN_GFX_D3D12) gn_vkd3d_unlock(); - gn_phase_account(2, GetTickCount64() - phase_start); @@ -3050,13 +3004,11 @@ static XrResult XRAPI_CALL gn_xrWaitSwapchainImage(XrSwapchain swapchain, const } if (state->submitted[index]) { struct gn_unix_acquire_image_args args; - unsigned long long phase_start = GetTickCount64(); args.slot = (gn_u32)slot; args.image_index = index; args.timeout_ns = waitInfo->timeout; args.result = GN_UNIX_ERROR_UNAVAILABLE; if (!gn_unix_call(GN_UNIX_ACQUIRE_IMAGE, &args)) return XR_ERROR_RUNTIME_FAILURE; - gn_phase_account(3, GetTickCount64() - phase_start); if (args.result == GN_UNIX_ERROR_TIMEOUT) return XR_TIMEOUT_EXPIRED; if (args.result != GN_UNIX_SUCCESS) return XR_ERROR_RUNTIME_FAILURE; state->submitted[index] = 0; From 632a55cb1cd802d66d0381ded67faeb5af39d5dd Mon Sep 17 00:00:00 2001 From: Utkarsh Dalal Date: Sun, 23 Aug 2026 11:11:58 +0530 Subject: [PATCH 18/46] Per-container VR render scale, default native --- .../app/gamenative/ui/component/dialog/GraphicsTab.kt | 10 ++++++++++ .../ui/screen/xr/windows/WindowsVrControlServer.kt | 7 +++---- .../ui/screen/xr/windows/WindowsVrRuntimeConfig.kt | 2 ++ .../main/java/app/gamenative/utils/ContainerUtils.kt | 2 ++ .../main/java/com/winlator/container/Container.java | 9 +++++++++ .../main/java/com/winlator/container/ContainerData.kt | 3 +++ app/src/main/res/values-da/strings.xml | 1 + app/src/main/res/values-de/strings.xml | 1 + app/src/main/res/values-es/strings.xml | 1 + app/src/main/res/values-fr/strings.xml | 1 + app/src/main/res/values-it/strings.xml | 1 + app/src/main/res/values-ja/strings.xml | 1 + app/src/main/res/values-ko/strings.xml | 1 + app/src/main/res/values-pl/strings.xml | 1 + app/src/main/res/values-pt-rBR/strings.xml | 1 + app/src/main/res/values-ro/strings.xml | 1 + app/src/main/res/values-ru/strings.xml | 1 + app/src/main/res/values-uk/strings.xml | 1 + app/src/main/res/values-zh-rCN/strings.xml | 1 + app/src/main/res/values-zh-rTW/strings.xml | 1 + app/src/main/res/values/strings.xml | 1 + 21 files changed, 44 insertions(+), 4 deletions(-) diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/GraphicsTab.kt b/app/src/main/java/app/gamenative/ui/component/dialog/GraphicsTab.kt index b30143fd4a..d23d6dad07 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/GraphicsTab.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/GraphicsTab.kt @@ -183,6 +183,16 @@ fun GraphicsTabContent(state: ContainerConfigState, default: Boolean = false) { state.config.value = config.copy(xrRefreshRate = xrRates[idx]) }, ) + val xrScales = listOf(50, 65, 75, 85, 100) + SettingsListDropdown( + colors = settingsTileColors(), + title = { Text(text = stringResource(R.string.xr_render_scale)) }, + value = xrScales.indexOf(config.xrRenderScale).let { if (it >= 0) it else xrScales.lastIndex }, + items = xrScales.map { "$it%" }, + onItemSelected = { idx -> + state.config.value = config.copy(xrRenderScale = xrScales[idx]) + }, + ) } SettingsListDropdown( colors = settingsTileColors(), diff --git a/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrControlServer.kt b/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrControlServer.kt index cae711d77c..1835ee10a1 100644 --- a/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrControlServer.kt +++ b/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrControlServer.kt @@ -193,10 +193,9 @@ class WindowsVrControlServer( private fun getViews(): String { val snapshot = currentSnapshot() ?: return "ERROR unavailable" - // The recommended per-eye size is far beyond what an emulated producer can fill; - // halve it (even dimensions) — quarter the pixels for render, copy, and upload. - val scaledWidth = (snapshot.timing[5] * 17 / 20) and 1L.inv() - val scaledHeight = (snapshot.timing[6] * 17 / 20) and 1L.inv() + val scale = config.renderScalePercent.toLong() + val scaledWidth = (snapshot.timing[5] * scale / 100) and 1L.inv() + val scaledHeight = (snapshot.timing[6] * scale / 100) and 1L.inv() return "OK count=2 width=$scaledWidth height=$scaledHeight" } diff --git a/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrRuntimeConfig.kt b/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrRuntimeConfig.kt index 7ccc6ba0cb..67a474f475 100644 --- a/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrRuntimeConfig.kt +++ b/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrRuntimeConfig.kt @@ -10,12 +10,14 @@ data class WindowsVrRuntimeConfig( val runtimeDirectory: String = "C:\\gamenative-xr", val runtimeManifest: String = "C:\\gamenative-xr\\active_runtime.json", val transportEndpoint: String = "@gamenative-xr", + val renderScalePercent: Int = 100, ) { companion object { fun from(container: Container): WindowsVrRuntimeConfig { return WindowsVrRuntimeConfig( enabled = container.getExtra("windowsVrEnabled", "true").toBoolean(), openCompositeEnabled = container.getExtra("windowsVrOpenCompositeEnabled", "false").toBoolean(), + renderScalePercent = container.xrRenderScale.coerceIn(25, 100), ) } } diff --git a/app/src/main/java/app/gamenative/utils/ContainerUtils.kt b/app/src/main/java/app/gamenative/utils/ContainerUtils.kt index 59795c3ea0..26131d87be 100644 --- a/app/src/main/java/app/gamenative/utils/ContainerUtils.kt +++ b/app/src/main/java/app/gamenative/utils/ContainerUtils.kt @@ -305,6 +305,7 @@ object ContainerUtils { rendererPresentMode = container.rendererPresentMode, displayRenderer = container.displayRenderer, xrRefreshRate = container.xrRefreshRate, + xrRenderScale = container.xrRenderScale, sfCompatMode = container.sfCompatMode, dxwrapper = container.dxWrapper, dxwrapperConfig = container.dxWrapperConfig, @@ -489,6 +490,7 @@ object ContainerUtils { container.rendererPresentMode = containerData.rendererPresentMode container.displayRenderer = containerData.displayRenderer container.xrRefreshRate = containerData.xrRefreshRate + container.xrRenderScale = containerData.xrRenderScale container.sfCompatMode = containerData.sfCompatMode container.dxWrapper = containerData.dxwrapper container.dxWrapperConfig = containerData.dxwrapperConfig diff --git a/app/src/main/java/com/winlator/container/Container.java b/app/src/main/java/com/winlator/container/Container.java index bb10897e7b..c0205148da 100644 --- a/app/src/main/java/com/winlator/container/Container.java +++ b/app/src/main/java/com/winlator/container/Container.java @@ -86,6 +86,7 @@ public enum XrControllerMapping { private String rendererPresentMode = "fifo"; private String displayRenderer = Container.DEFAULT_DISPLAY_RENDERER; private int xrRefreshRate = 72; + private int xrRenderScale = 100; private boolean sfCompatMode = true; private String wincomponents = DEFAULT_WINCOMPONENTS; private String audioDriver = DEFAULT_AUDIO_DRIVER; @@ -278,6 +279,10 @@ public void setGraphicsDriverConfig(String graphicsDriverConfig) { public void setXrRefreshRate(int v) { this.xrRefreshRate = v; } + public int getXrRenderScale() { return xrRenderScale; } + + public void setXrRenderScale(int v) { this.xrRenderScale = v; } + public void setDisplayRenderer(String v) { this.displayRenderer = v; } public boolean getSfCompatMode() { return sfCompatMode; } @@ -703,6 +708,7 @@ public void saveData() { data.put("rendererPresentMode", rendererPresentMode); data.put("displayRendererMode", displayRenderer); data.put("xrRefreshRate", xrRefreshRate); + data.put("xrRenderScale", xrRenderScale); data.put("sfCompatMode", sfCompatMode); data.put("dxwrapper", dxwrapper); if (!dxwrapperConfig.isEmpty()) data.put("dxwrapperConfig", dxwrapperConfig); @@ -831,6 +837,9 @@ public void loadData(JSONObject data) throws JSONException { case "xrRefreshRate" : setXrRefreshRate(data.getInt(key)); break; + case "xrRenderScale" : + setXrRenderScale(data.getInt(key)); + break; case "sfCompatMode" : setSfCompatMode(data.getBoolean(key)); break; diff --git a/app/src/main/java/com/winlator/container/ContainerData.kt b/app/src/main/java/com/winlator/container/ContainerData.kt index 11093b1ec1..b1b5e3f5e1 100644 --- a/app/src/main/java/com/winlator/container/ContainerData.kt +++ b/app/src/main/java/com/winlator/container/ContainerData.kt @@ -20,6 +20,7 @@ data class ContainerData( val rendererPresentMode: String = "fifo", val displayRenderer: String = Container.DEFAULT_DISPLAY_RENDERER, val xrRefreshRate: Int = 72, + val xrRenderScale: Int = 100, val sfCompatMode: Boolean = true, var dxwrapper: String = Container.DEFAULT_DXWRAPPER, val dxwrapperConfig: String = "", @@ -122,6 +123,7 @@ data class ContainerData( "rendererPresentMode" to state.rendererPresentMode, "displayRenderer" to state.displayRenderer, "xrRefreshRate" to state.xrRefreshRate, + "xrRenderScale" to state.xrRenderScale, "sfCompatMode" to state.sfCompatMode, "dxwrapper" to state.dxwrapper, "dxwrapperConfig" to state.dxwrapperConfig, @@ -193,6 +195,7 @@ data class ContainerData( rendererPresentMode = (savedMap["rendererPresentMode"] as? String) ?: "fifo", displayRenderer = (savedMap["displayRenderer"] as? String) ?: "vulkan", xrRefreshRate = (savedMap["xrRefreshRate"] as? Int) ?: 72, + xrRenderScale = (savedMap["xrRenderScale"] as? Int) ?: 100, sfCompatMode = (savedMap["sfCompatMode"] as? Boolean) ?: true, dxwrapper = savedMap["dxwrapper"] as String, dxwrapperConfig = savedMap["dxwrapperConfig"] as String, diff --git a/app/src/main/res/values-da/strings.xml b/app/src/main/res/values-da/strings.xml index 68132fc377..253937dc66 100644 --- a/app/src/main/res/values-da/strings.xml +++ b/app/src/main/res/values-da/strings.xml @@ -2209,4 +2209,5 @@ Føjet til favoritter Føjede %1$s til favoritter VR-opdateringsfrekvens + VR-gengivelsesskala diff --git a/app/src/main/res/values-de/strings.xml b/app/src/main/res/values-de/strings.xml index f8e1f16d9b..9eba3e9f4b 100644 --- a/app/src/main/res/values-de/strings.xml +++ b/app/src/main/res/values-de/strings.xml @@ -2279,4 +2279,5 @@ Zu Favoriten hinzugefügt %1$s zu Favoriten hinzugefügt VR-Bildwiederholrate + VR-Renderskalierung diff --git a/app/src/main/res/values-es/strings.xml b/app/src/main/res/values-es/strings.xml index 427159ce24..c3396993dc 100644 --- a/app/src/main/res/values-es/strings.xml +++ b/app/src/main/res/values-es/strings.xml @@ -2337,4 +2337,5 @@ Añadido a favoritos %1$s añadido a favoritos Frecuencia de actualización de RV + Escala de renderizado de RV diff --git a/app/src/main/res/values-fr/strings.xml b/app/src/main/res/values-fr/strings.xml index 3dd7479c3b..d83176323f 100644 --- a/app/src/main/res/values-fr/strings.xml +++ b/app/src/main/res/values-fr/strings.xml @@ -2339,4 +2339,5 @@ Ajouté aux favoris %1$s ajouté aux favoris Taux de rafraîchissement VR + Échelle de rendu VR diff --git a/app/src/main/res/values-it/strings.xml b/app/src/main/res/values-it/strings.xml index 69e213cebc..2531c4e1ad 100644 --- a/app/src/main/res/values-it/strings.xml +++ b/app/src/main/res/values-it/strings.xml @@ -2330,4 +2330,5 @@ Aggiunto ai preferiti %1$s aggiunto ai preferiti Frequenza di aggiornamento VR + Scala di rendering VR diff --git a/app/src/main/res/values-ja/strings.xml b/app/src/main/res/values-ja/strings.xml index 3787795feb..b3c49da279 100644 --- a/app/src/main/res/values-ja/strings.xml +++ b/app/src/main/res/values-ja/strings.xml @@ -2293,4 +2293,5 @@ お気に入りに追加しました %1$s をお気に入りに追加しました VRリフレッシュレート + VRレンダースケール diff --git a/app/src/main/res/values-ko/strings.xml b/app/src/main/res/values-ko/strings.xml index 97cb10a2fe..50454f9070 100644 --- a/app/src/main/res/values-ko/strings.xml +++ b/app/src/main/res/values-ko/strings.xml @@ -2334,4 +2334,5 @@ 즐겨찾기에 추가됨 %1$s을(를) 즐겨찾기에 추가함 VR 재생 빈도 + VR 렌더링 배율 diff --git a/app/src/main/res/values-pl/strings.xml b/app/src/main/res/values-pl/strings.xml index 3794bebdab..54249e3fe3 100644 --- a/app/src/main/res/values-pl/strings.xml +++ b/app/src/main/res/values-pl/strings.xml @@ -2343,4 +2343,5 @@ Dodano do ulubionych Dodano %1$s do ulubionych Częstotliwość odświeżania VR + Skala renderowania VR diff --git a/app/src/main/res/values-pt-rBR/strings.xml b/app/src/main/res/values-pt-rBR/strings.xml index bbf24b52ff..49efd94d74 100644 --- a/app/src/main/res/values-pt-rBR/strings.xml +++ b/app/src/main/res/values-pt-rBR/strings.xml @@ -2209,4 +2209,5 @@ Adicionado aos favoritos %1$s adicionado aos favoritos Taxa de atualização de VR + Escala de renderização de VR diff --git a/app/src/main/res/values-ro/strings.xml b/app/src/main/res/values-ro/strings.xml index 751d77e339..3c234f755c 100644 --- a/app/src/main/res/values-ro/strings.xml +++ b/app/src/main/res/values-ro/strings.xml @@ -2343,4 +2343,5 @@ Adăugat la favorite %1$s adăugat la favorite Rată de reîmprospătare VR + Scară de randare VR diff --git a/app/src/main/res/values-ru/strings.xml b/app/src/main/res/values-ru/strings.xml index 1812132be3..8380d78df8 100644 --- a/app/src/main/res/values-ru/strings.xml +++ b/app/src/main/res/values-ru/strings.xml @@ -2271,4 +2271,5 @@ https://gamenative.app Добавлено в избранное %1$s добавлено в избранное Частота обновления VR + Масштаб рендеринга VR diff --git a/app/src/main/res/values-uk/strings.xml b/app/src/main/res/values-uk/strings.xml index d86322c79c..2d7e747ad6 100644 --- a/app/src/main/res/values-uk/strings.xml +++ b/app/src/main/res/values-uk/strings.xml @@ -2339,4 +2339,5 @@ Додано до вибраного %1$s додано до вибраного Частота оновлення VR + Масштаб рендерингу VR diff --git a/app/src/main/res/values-zh-rCN/strings.xml b/app/src/main/res/values-zh-rCN/strings.xml index 634d2a888e..f152f2db0a 100644 --- a/app/src/main/res/values-zh-rCN/strings.xml +++ b/app/src/main/res/values-zh-rCN/strings.xml @@ -2354,4 +2354,5 @@ 已添加到收藏 已将 %1$s 添加到收藏 VR 刷新率 + VR 渲染比例 diff --git a/app/src/main/res/values-zh-rTW/strings.xml b/app/src/main/res/values-zh-rTW/strings.xml index d0f63734d8..8203b3c6d0 100644 --- a/app/src/main/res/values-zh-rTW/strings.xml +++ b/app/src/main/res/values-zh-rTW/strings.xml @@ -2345,4 +2345,5 @@ 已加入收藏 已將 %1$s 加入收藏 VR 重新整理頻率 + VR 算繪比例 diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index d03963901c..1e080ea082 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -2346,4 +2346,5 @@ Conservative AdjustsGradual gradually with a focus on stability VR Refresh Rate + VR Render Scale From 55bd729acba622c6159f4a85bc4f0a5d92544216 Mon Sep 17 00:00:00 2001 From: Utkarsh Dalal Date: Sun, 23 Aug 2026 11:23:57 +0530 Subject: [PATCH 19/46] Render scale as a slider (25-100%, 5% steps) --- .../ui/component/dialog/GraphicsTab.kt | 22 ++++++++++--------- 1 file changed, 12 insertions(+), 10 deletions(-) diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/GraphicsTab.kt b/app/src/main/java/app/gamenative/ui/component/dialog/GraphicsTab.kt index d23d6dad07..4acec3fef8 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/GraphicsTab.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/GraphicsTab.kt @@ -183,16 +183,18 @@ fun GraphicsTabContent(state: ContainerConfigState, default: Boolean = false) { state.config.value = config.copy(xrRefreshRate = xrRates[idx]) }, ) - val xrScales = listOf(50, 65, 75, 85, 100) - SettingsListDropdown( - colors = settingsTileColors(), - title = { Text(text = stringResource(R.string.xr_render_scale)) }, - value = xrScales.indexOf(config.xrRenderScale).let { if (it >= 0) it else xrScales.lastIndex }, - items = xrScales.map { "$it%" }, - onItemSelected = { idx -> - state.config.value = config.copy(xrRenderScale = xrScales[idx]) - }, - ) + Column(modifier = Modifier.padding(horizontal = 16.dp, vertical = 8.dp)) { + Text(text = stringResource(R.string.xr_render_scale)) + Slider( + value = config.xrRenderScale.toFloat(), + onValueChange = { newValue -> + val stepped = ((newValue.roundToInt() + 2) / 5 * 5).coerceIn(25, 100) + state.config.value = config.copy(xrRenderScale = stepped) + }, + valueRange = 25f..100f, + ) + Text(text = "${config.xrRenderScale}%") + } } SettingsListDropdown( colors = settingsTileColors(), From 4bd1aa2ae956e024bbd0b611eecf51481c094905 Mon Sep 17 00:00:00 2001 From: Utkarsh Dalal Date: Sun, 23 Aug 2026 11:28:16 +0530 Subject: [PATCH 20/46] Log the EGL error and extension support when dma-buf import fails --- .../main/cpp/xrimmersive/xr_windows_projection.cpp | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/app/src/main/cpp/xrimmersive/xr_windows_projection.cpp b/app/src/main/cpp/xrimmersive/xr_windows_projection.cpp index c1510661b4..dce7f1b0df 100644 --- a/app/src/main/cpp/xrimmersive/xr_windows_projection.cpp +++ b/app/src/main/cpp/xrimmersive/xr_windows_projection.cpp @@ -3,6 +3,7 @@ #include #include #include +#include #include #include #include @@ -307,7 +308,16 @@ bool WindowsProjectionPresenter::importEyeBuffer(WindowsFrameTransport &transpor imported = createImageFromDmabuf(frame); if (imported == EGL_NO_IMAGE_KHR) { cpuFallback_[eye][image] = true; - LOGI("windows vr eye %u image %d: EGL dma-buf import failed — CPU upload fallback engaged", eye, image); + static bool details = false; + LOGI("windows vr eye %u image %d: EGL dma-buf import failed (0x%x) — CPU upload fallback engaged", + eye, image, eglGetError()); + if (!details) { + details = true; + const char *extensions = eglQueryString(display_, EGL_EXTENSIONS); + LOGI("EGL dma_buf_import=%d modifiers=%d", + extensions != nullptr && strstr(extensions, "EGL_EXT_image_dma_buf_import") != nullptr, + extensions != nullptr && strstr(extensions, "EGL_EXT_image_dma_buf_import_modifiers") != nullptr); + } if (uploadLinearDmabufToTexture(eye, image, frame, cachedTexture, registration)) return true; } else { LOGI("windows vr eye %u image %d: zero-copy EGL dma-buf import active", eye, image); From 6c92c477944caabb2a5844d91a92226ee4ff3dd7 Mon Sep 17 00:00:00 2001 From: Utkarsh Dalal Date: Thu, 27 Aug 2026 20:12:00 +0530 Subject: [PATCH 21/46] One-command payload build for macOS --- tools/build-xr-payload-macos.sh | 85 +++++++++++++++++++++++++++++++++ 1 file changed, 85 insertions(+) create mode 100755 tools/build-xr-payload-macos.sh diff --git a/tools/build-xr-payload-macos.sh b/tools/build-xr-payload-macos.sh new file mode 100755 index 0000000000..ca94133515 --- /dev/null +++ b/tools/build-xr-payload-macos.sh @@ -0,0 +1,85 @@ +#!/bin/bash +# Builds the complete Windows-VR payload on macOS into app/build/generated/xrPayload/modernXr. +# +# tools/build-xr-payload-macos.sh # runtime DLLs + unixlib (the usual iteration loop) +# tools/build-xr-payload-macos.sh --bridge # also the arm64x Wine builtin (Docker; slow first run) +# +# After this, `./gradlew assembleModernXrDebug` packages everything. +set -eu + +repository="$(cd "$(dirname "$0")/.." && pwd)" +sdk="${ANDROID_HOME:-$HOME/Library/Android/sdk}" +ndk="$sdk/ndk/27.3.13750724" +bin="$ndk/toolchains/llvm/prebuilt/darwin-x86_64/bin" +cmake="$sdk/cmake/3.22.1/bin/cmake" +ninja="$sdk/cmake/3.22.1/bin/ninja" +source_dir="$repository/app/src/main/windows/openxr_runtime" +work="$repository/app/build/xr-payload-macos" +output="$repository/app/build/generated/xrPayload/modernXr" +mkdir -p "$work" "$output" + +# OpenXR headers (pinned to the same release the Windows build uses). +if [ ! -f "$work/inc/openxr/openxr.h" ]; then + mkdir -p "$work/inc/openxr" + curl -sL https://github.com/KhronosGroup/OpenXR-SDK/archive/refs/tags/release-1.1.61.tar.gz \ + | tar -xz -C "$work" --strip-components=2 "OpenXR-SDK-release-1.1.61/include/openxr" + mv "$work/openxr/"*.h "$work/inc/openxr/" 2>/dev/null || true + cp -R "$work"/*.h "$work/inc/openxr/" 2>/dev/null || true + [ -f "$work/inc/openxr/openxr.h" ] || { echo "OpenXR headers missing"; exit 1; } +fi + +# Import libraries from the .def files. +for lib in ws2_32 kernel32 ntdll dxgi; do + "$bin/llvm-dlltool" -m i386:x86-64 -d "$source_dir/${lib}_x64.def" -l "$work/lib${lib}_x64.a" + "$bin/llvm-dlltool" -m i386 -k -d "$source_dir/${lib}_x86.def" -l "$work/lib${lib}_x86.a" +done + +# The two OpenXR runtime DLLs (CRT-less PE, built with the NDK's clang). +"$bin/clang" --target=x86_64-w64-windows-gnu -shared -nostdlib -Wl,-e,DllMain -I "$work/inc" \ + -o "$output/gamenative_openxr_runtime64.dll" \ + "$source_dir/gamenative_openxr_runtime.c" "$source_dir/gamenative_openxr_runtime_x64.def" \ + "$work/libws2_32_x64.a" "$work/libkernel32_x64.a" "$work/libntdll_x64.a" "$work/libdxgi_x64.a" +"$bin/clang" --target=i686-w64-windows-gnu -shared -nostdlib -Wl,-e,DllMain -I "$work/inc" \ + -o "$output/gamenative_openxr_runtime32.dll" \ + "$source_dir/gamenative_openxr_runtime.c" "$source_dir/gamenative_openxr_runtime_x86.def" \ + "$work/libws2_32_x86.a" "$work/libkernel32_x86.a" "$work/libntdll_x86.a" "$work/libdxgi_x86.a" +hash64=$(shasum -a 256 "$output/gamenative_openxr_runtime64.dll" | cut -d' ' -f1) +hash32=$(shasum -a 256 "$output/gamenative_openxr_runtime32.dll" | cut -d' ' -f1) +printf "3 %s %s" "$hash64" "$hash32" > "$output/payload.version" + +# The Wine unixlib (plain NDK shared library). +"$cmake" -S "$source_dir/unix" -B "$work/unixlib" -GNinja \ + -DCMAKE_MAKE_PROGRAM="$ninja" \ + -DCMAKE_TOOLCHAIN_FILE="$ndk/build/cmake/android.toolchain.cmake" \ + -DANDROID_ABI=arm64-v8a -DANDROID_PLATFORM=android-28 -DCMAKE_BUILD_TYPE=Release >/dev/null +"$cmake" --build "$work/unixlib" +cp "$work/unixlib/gamenative_xr_unixbridge.so" "$output/" + +# The 32-bit Wine builtin stub ships prebuilt in the repo. +cp "$source_dir/builtin/gamenative_xr_unixbridge32.dll" "$output/" + +# OpenComposite (pinned download, checksum-verified) for OpenVR titles. +if [ ! -f "$output/opencomposite_x64.dll" ]; then + curl -sL "https://opencomposite.znix.xyz/builds/download_build?artefact_id=5r2yCwgFn_ozJ44c&build_id=49918237&commit=43e551a4506880ab1a71b8b9fec2fd7fbb27372f" \ + -o "$output/opencomposite_x64.dll" + echo "2f56d45323f252a2ea7c3047c806f9aca3cab36c3f9f71d1dad05a5008b7731a $output/opencomposite_x64.dll" \ + | shasum -a 256 -c - >/dev/null || { echo "OpenComposite checksum mismatch"; exit 1; } +fi + +# The arm64x Wine builtin needs Linux; run it in Docker on request. +# The gn-arm64x volume caches the toolchains and Wine tree, so reruns take minutes. +if [ "${1:-}" = "--bridge" ]; then + docker run --rm --platform linux/amd64 \ + -v gn-arm64x:/root/gamenative-arm64x -v "$repository":/repo ubuntu:22.04 bash -c ' +set -e +export DEBIAN_FRONTEND=noninteractive +apt-get update -qq +apt-get install -y -qq build-essential flex bison git wget unzip xz-utils python3 perl pkg-config autoconf automake ca-certificates file >/dev/null +mkdir -p /root/Android/Sdk/ndk +cd /repo && bash tools/provision-build-arm64x-wine-bridge.sh /repo' +elif [ ! -f "$output/gamenative_xr_unixbridge.dll" ]; then + echo "note: arm64x bridge DLL not present — run with --bridge to build it (Docker)" +fi + +echo "payload ready:" +ls -la "$output" From db3b05dd60f6afa1778a5f29ff04d5ee33c00d5e Mon Sep 17 00:00:00 2001 From: Utkarsh Dalal Date: Thu, 27 Aug 2026 21:59:03 +0530 Subject: [PATCH 22/46] Render into compressed (UBWC) targets when the relay carries the frames --- .../unix/gamenative_openxr_unix.c | 60 ++++++++++++++++--- 1 file changed, 52 insertions(+), 8 deletions(-) diff --git a/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c b/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c index 5ebc6afff9..bcd42a328d 100644 --- a/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c +++ b/app/src/main/windows/openxr_runtime/unix/gamenative_openxr_unix.c @@ -62,6 +62,7 @@ struct gn_image { uint32_t plane_count; uint32_t strides[4]; uint32_t offsets[4]; + uint64_t array_pitches[4]; uint64_t modifier; uint8_t registered_eye_mask; uint32_t registered_array_index[2]; @@ -84,6 +85,9 @@ struct gn_swapchain { }; static void submit_worker_flush(void); +#if defined(__ANDROID__) +static int relay_init(void); +#endif static uint8_t image_copy_busy[32u][4u]; static pthread_mutex_t submit_mutex = PTHREAD_MUTEX_INITIALIZER; static pthread_cond_t submit_space_cond = PTHREAD_COND_INITIALIZER; @@ -641,6 +645,14 @@ static int create_image(struct gn_swapchain *swapchain, struct gn_image *out, uint64_t chosen_modifier = 0; uint32_t chosen_plane_count = 1; int has_chosen_modifier = 0; + /* When the relay carries the frames the consumer never touches the dma-buf + * directly, so the game can render into a bandwidth-compressed (non-linear) + * layout — a large win for fill-heavy titles. The linear layout stays for + * the CPU-readable fallback path. */ + int prefer_compressed = 0; +#if defined(__ANDROID__) + prefer_compressed = sample_count <= 1 && relay_init(); +#endif if (p_vkGetPhysicalDeviceFormatProperties2) { p_vkGetPhysicalDeviceFormatProperties2(physical_device, swapchain->format, &format_props); if (modifier_list.drmFormatModifierCount) { @@ -653,16 +665,15 @@ static int create_image(struct gn_swapchain *swapchain, struct gn_image *out, (features & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) && modifiers[i].drmFormatModifierPlaneCount >= 1 && modifiers[i].drmFormatModifierPlaneCount <= 4) { - - - - if (!has_chosen_modifier || modifiers[i].drmFormatModifier == 0) { + const int is_linear = modifiers[i].drmFormatModifier == 0; + const int preferred = prefer_compressed ? !is_linear : is_linear; + if (!has_chosen_modifier || preferred) { chosen_modifier = modifiers[i].drmFormatModifier; chosen_plane_count = modifiers[i].drmFormatModifierPlaneCount; has_chosen_modifier = 1; } - if (modifiers[i].drmFormatModifier == 0) break; + if (preferred) break; } } } @@ -694,9 +705,17 @@ static int create_image(struct gn_swapchain *swapchain, struct gn_image *out, - int memory_type = find_memory_type( - requirements.memoryTypeBits, - VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT); + int memory_type; + if (has_chosen_modifier && chosen_modifier != 0) { + memory_type = find_memory_type( + requirements.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT); + if (memory_type < 0) + memory_type = find_memory_type(requirements.memoryTypeBits, 0); + } else { + memory_type = find_memory_type( + requirements.memoryTypeBits, + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT); + } if (memory_type < 0) { log_line("No compatible memory type for dma-buf image"); goto fail; @@ -758,6 +777,7 @@ static int create_image(struct gn_swapchain *swapchain, struct gn_image *out, device, out->image, &subresource, &layout); out->strides[plane] = (uint32_t)layout.rowPitch; out->offsets[plane] = (uint32_t)layout.offset; + out->array_pitches[plane] = layout.arrayPitch; } out->modifier = has_chosen_modifier ? chosen_modifier : 0; if (has_chosen_modifier && p_vkGetImageDrmFormatModifierPropertiesEXT) { @@ -1026,6 +1046,8 @@ static int relay_init(void) "VK_EXT_queue_family_foreign", "VK_KHR_sampler_ycbcr_conversion", "VK_KHR_external_fence_fd", + "VK_EXT_image_drm_format_modifier", + "VK_KHR_image_format_list", "VK_KHR_dedicated_allocation", "VK_KHR_get_memory_requirements2", "VK_KHR_bind_memory2", @@ -1148,6 +1170,13 @@ static int relay_create_source(struct gn_swapchain *swapchain, struct gn_image * .sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, .handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT }; + VkSubresourceLayout plane_layouts[4]; + VkImageDrmFormatModifierExplicitCreateInfoEXT modifier_info = { + .sType = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT, + .drmFormatModifier = image->modifier, + .drmFormatModifierPlaneCount = image->plane_count, + .pPlaneLayouts = plane_layouts + }; VkImageCreateInfo image_info = { .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, .pNext = &external, @@ -1162,6 +1191,17 @@ static int relay_create_source(struct gn_swapchain *swapchain, struct gn_image * .sharingMode = VK_SHARING_MODE_EXCLUSIVE, .initialLayout = VK_IMAGE_LAYOUT_UNDEFINED }; + if (image->modifier != 0) { + for (uint32_t plane = 0; plane < image->plane_count && plane < 4; ++plane) { + memset(&plane_layouts[plane], 0, sizeof(plane_layouts[plane])); + plane_layouts[plane].offset = image->offsets[plane]; + plane_layouts[plane].rowPitch = image->strides[plane]; + plane_layouts[plane].arrayPitch = image->array_pitches[plane]; + } + modifier_info.pNext = (void *)image_info.pNext; + image_info.pNext = &modifier_info; + image_info.tiling = VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT; + } if (r_vkCreateImage(relay_device, &image_info, NULL, &image->relay_source_image) != VK_SUCCESS) { log_line("relay: source image create failed"); close(fd); @@ -1847,6 +1887,10 @@ static int register_image(uint32_t slot, uint32_t image_index, uint32_t eye, log_line("optimal render image has no dma-buf; AHardwareBuffer transport is required"); return 0; } + if (image->modifier != 0) { + log_line("compressed render image cannot use the dma-buf fallback; relay is required"); + return 0; + } VkSubresourceLayout layouts[4]; for (uint32_t plane = 0; plane < image->plane_count; ++plane) { From 5c2f1ee060c34f59aef019827c7e6529de16d7bf Mon Sep 17 00:00:00 2001 From: Utkarsh Dalal Date: Thu, 3 Sep 2026 19:54:26 +0530 Subject: [PATCH 23/46] Make Windows VR opt-in per container and fail soft when the payload is unavailable --- .../ui/component/dialog/GraphicsTab.kt | 9 +++++++ .../ui/screen/xr/ImmersiveControls.kt | 2 +- .../ui/screen/xr/ImmersiveXrActivity.kt | 12 ++++++--- .../xr/windows/WindowsVrRuntimeConfig.kt | 2 +- .../xr/windows/WindowsVrRuntimeService.kt | 26 ++++++++++++++----- .../app/gamenative/utils/ContainerUtils.kt | 2 ++ .../com/winlator/container/ContainerData.kt | 3 +++ app/src/main/res/values/strings.xml | 2 ++ 8 files changed, 45 insertions(+), 13 deletions(-) diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/GraphicsTab.kt b/app/src/main/java/app/gamenative/ui/component/dialog/GraphicsTab.kt index 4acec3fef8..3821efc905 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/GraphicsTab.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/GraphicsTab.kt @@ -195,6 +195,15 @@ fun GraphicsTabContent(state: ContainerConfigState, default: Boolean = false) { ) Text(text = "${config.xrRenderScale}%") } + SettingsSwitch( + colors = settingsTileColorsAlt(), + title = { Text(text = stringResource(R.string.xr_windows_vr_toggle)) }, + subtitle = { Text(text = stringResource(R.string.xr_windows_vr_toggle_desc)) }, + state = config.windowsVrEnabled, + onCheckedChange = { checked -> + state.config.value = config.copy(windowsVrEnabled = checked) + }, + ) } SettingsListDropdown( colors = settingsTileColors(), diff --git a/app/src/main/java/app/gamenative/ui/screen/xr/ImmersiveControls.kt b/app/src/main/java/app/gamenative/ui/screen/xr/ImmersiveControls.kt index 43757c24a7..cb24d00a42 100644 --- a/app/src/main/java/app/gamenative/ui/screen/xr/ImmersiveControls.kt +++ b/app/src/main/java/app/gamenative/ui/screen/xr/ImmersiveControls.kt @@ -12,7 +12,7 @@ data class ImmersiveControls( val onResetScreenEffects: () -> Unit = {}, val resizeModeEnabled: Boolean = false, val onResizeModeToggle: (Boolean) -> Unit = {}, - val windowsVrEnabled: Boolean = true, + val windowsVrEnabled: Boolean = false, val onWindowsVrToggle: (Boolean) -> Unit = {}, val openCompositeEnabled: Boolean = false, val onOpenCompositeToggle: (Boolean) -> Unit = {}, diff --git a/app/src/main/java/app/gamenative/ui/screen/xr/ImmersiveXrActivity.kt b/app/src/main/java/app/gamenative/ui/screen/xr/ImmersiveXrActivity.kt index 25a70ced10..e67f761488 100644 --- a/app/src/main/java/app/gamenative/ui/screen/xr/ImmersiveXrActivity.kt +++ b/app/src/main/java/app/gamenative/ui/screen/xr/ImmersiveXrActivity.kt @@ -225,7 +225,7 @@ class ImmersiveXrActivity : androidx.activity.ComponentActivity() { private var quadVertical by mutableFloatStateOf(ImmersiveControls.DEFAULT_OFFSET) private var quadScale by mutableFloatStateOf(ImmersiveControls.DEFAULT_SCALE) private var passthroughEnabled by mutableStateOf(false) - private var windowsVrEnabled by mutableStateOf(true) + private var windowsVrEnabled by mutableStateOf(false) private var openCompositeEnabled by mutableStateOf(false) private var windowsVrStatus by mutableStateOf("Waiting for runtime") private var showControlsOnboarding by mutableStateOf(false) @@ -294,8 +294,12 @@ class ImmersiveXrActivity : androidx.activity.ComponentActivity() { }, onGameLaunchError = { error -> viewModel.onGameLaunchError(error) - runOnUiThread { windowsVrStatus = "Guest stopped: $error" } - windowsVrRuntimeService?.onGuestProcessError(error) + if (windowsVrEnabled) { + runOnUiThread { windowsVrStatus = "Guest stopped: $error" } + windowsVrRuntimeService?.onGuestProcessError(error) + } else { + finish() + } }, immersiveHooks = ImmersiveSessionHooks( windowsVr = windowsVrRuntimeService, @@ -401,7 +405,7 @@ class ImmersiveXrActivity : androidx.activity.ComponentActivity() { quadScale = container.getExtra(EXTRA_QUAD_SCALE, ImmersiveControls.DEFAULT_SCALE.toString()) .toFloatOrNull() ?: ImmersiveControls.DEFAULT_SCALE passthroughEnabled = container.getExtra(EXTRA_PASSTHROUGH_ENABLED, "false").toBoolean() - windowsVrEnabled = container.getExtra(EXTRA_WINDOWS_VR_ENABLED, "true").toBoolean() + windowsVrEnabled = container.getExtra(EXTRA_WINDOWS_VR_ENABLED, "false").toBoolean() openCompositeEnabled = container.getExtra(EXTRA_WINDOWS_VR_OPEN_COMPOSITE, "false").toBoolean() windowsVrStatus = if (windowsVrEnabled) "Waiting for runtime" else "Disabled" applyQuadTransform() diff --git a/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrRuntimeConfig.kt b/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrRuntimeConfig.kt index 67a474f475..66734e56c3 100644 --- a/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrRuntimeConfig.kt +++ b/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrRuntimeConfig.kt @@ -15,7 +15,7 @@ data class WindowsVrRuntimeConfig( companion object { fun from(container: Container): WindowsVrRuntimeConfig { return WindowsVrRuntimeConfig( - enabled = container.getExtra("windowsVrEnabled", "true").toBoolean(), + enabled = container.getExtra("windowsVrEnabled", "false").toBoolean(), openCompositeEnabled = container.getExtra("windowsVrOpenCompositeEnabled", "false").toBoolean(), renderScalePercent = container.xrRenderScale.coerceIn(25, 100), ) diff --git a/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrRuntimeService.kt b/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrRuntimeService.kt index f936b34889..e0b4723faf 100644 --- a/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrRuntimeService.kt +++ b/app/src/main/java/app/gamenative/ui/screen/xr/windows/WindowsVrRuntimeService.kt @@ -2,11 +2,13 @@ package app.gamenative.ui.screen.xr.windows import android.content.Context import app.gamenative.CrashHandler +import app.gamenative.ui.util.SnackbarManager import com.winlator.container.Container import com.winlator.core.ProcessHelper import com.winlator.core.envvars.EnvVars import java.io.Closeable import java.io.File +import timber.log.Timber class WindowsVrRuntimeService(context: Context) : Closeable { private val applicationContext = context.applicationContext @@ -32,14 +34,24 @@ class WindowsVrRuntimeService(context: Context) : Closeable { this.container = container val active = config ?: WindowsVrRuntimeConfig.from(container).also { config = it } if (!active.enabled) return - check(container.wineVersion.contains("arm64ec", ignoreCase = true)) { - "Windows VR requires a supported ARM64EC Wine or Proton build" - } - check(container.dxWrapper.contains("dxvk", ignoreCase = true)) { - "Windows VR D3D11 requires DXVK native interop" + val payload = try { + check(container.wineVersion.contains("arm64ec", ignoreCase = true)) { + "Windows VR requires a supported ARM64EC Wine or Proton build" + } + check(container.dxWrapper.contains("dxvk", ignoreCase = true)) { + "Windows VR D3D11 requires DXVK native interop" + } + diagnostics.record("launch", "Preparing Windows OpenXR payload") + payloadManager.prepare(container) + } catch (e: Exception) { + val reason = e.message ?: e.javaClass.simpleName + diagnostics.record("launch", "Windows VR disabled for this session: $reason") + Timber.w(e, "Windows VR disabled for this session") + SnackbarManager.show("VR mode unavailable: $reason") + runCatching { payloadManager.restore() } + config = active.copy(enabled = false) + return } - diagnostics.record("launch", "Preparing Windows OpenXR payload") - val payload = payloadManager.prepare(container) runtimeLogDirectory = payload.prefixDirectory listOf("runtime.log", "unix.log").forEach { payload.prefixDirectory.resolve(it).delete() } if (active.openCompositeEnabled) payloadManager.installOpenComposite(container) diff --git a/app/src/main/java/app/gamenative/utils/ContainerUtils.kt b/app/src/main/java/app/gamenative/utils/ContainerUtils.kt index 2667408332..a5b128daa5 100644 --- a/app/src/main/java/app/gamenative/utils/ContainerUtils.kt +++ b/app/src/main/java/app/gamenative/utils/ContainerUtils.kt @@ -369,6 +369,7 @@ object ContainerUtils { sharpnessDenoise = container.getExtra("sharpnessDenoise", "100").toIntOrNull() ?: 100, // LSFG Vulkan frame generation lsfgEnabled = container.getExtra(LsfgVkManager.EXTRA_ARMED, "false").toBoolean(), + windowsVrEnabled = container.getExtra("windowsVrEnabled", "false").toBoolean(), ) } @@ -557,6 +558,7 @@ object ContainerUtils { container.putExtra("sharpnessDenoise", containerData.sharpnessDenoise.toString()) // LSFG Vulkan frame generation container.putExtra(LsfgVkManager.EXTRA_ARMED, containerData.lsfgEnabled.toString()) + container.putExtra("windowsVrEnabled", containerData.windowsVrEnabled.toString()) try { container.language = containerData.language } catch (e: Exception) { diff --git a/app/src/main/java/com/winlator/container/ContainerData.kt b/app/src/main/java/com/winlator/container/ContainerData.kt index e361c3f8bd..d3a325deef 100644 --- a/app/src/main/java/com/winlator/container/ContainerData.kt +++ b/app/src/main/java/com/winlator/container/ContainerData.kt @@ -111,6 +111,7 @@ data class ContainerData( // LSFG Vulkan frame generation /** Whether LSFG frame generation is enabled for this container */ val lsfgEnabled: Boolean = false, + val windowsVrEnabled: Boolean = false, ) { companion object { val Saver = mapSaver( @@ -186,6 +187,7 @@ data class ContainerData( "sharpnessLevel" to state.sharpnessLevel, "sharpnessDenoise" to state.sharpnessDenoise, "lsfgEnabled" to state.lsfgEnabled, + "windowsVrEnabled" to state.windowsVrEnabled, ) }, restore = { savedMap -> @@ -260,6 +262,7 @@ data class ContainerData( sharpnessLevel = (savedMap["sharpnessLevel"] as? Int) ?: 100, sharpnessDenoise = (savedMap["sharpnessDenoise"] as? Int) ?: 100, lsfgEnabled = (savedMap["lsfgEnabled"] as? Boolean) ?: false, + windowsVrEnabled = (savedMap["windowsVrEnabled"] as? Boolean) ?: false, ) }, ) diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index 3aea508606..e4a32c7f94 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -2477,5 +2477,7 @@ %1$.1f°/s %1$d ms Reset gyro settings + Run as VR app (experimental) + For native VR titles such as Beat Saber. Needs arm64ec Wine and DXVK. Other games keep the flat immersive screen. VR Render Scale From 65f1e52a00b0dc869956718126df414e748722cd Mon Sep 17 00:00:00 2001 From: Utkarsh Dalal Date: Thu, 3 Sep 2026 21:00:06 +0530 Subject: [PATCH 24/46] Expose the OpenComposite toggle in container graphics settings --- .../app/gamenative/ui/component/dialog/GraphicsTab.kt | 11 +++++++++++ .../main/java/app/gamenative/utils/ContainerUtils.kt | 2 ++ .../main/java/com/winlator/container/ContainerData.kt | 3 +++ app/src/main/res/values/strings.xml | 2 ++ 4 files changed, 18 insertions(+) diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/GraphicsTab.kt b/app/src/main/java/app/gamenative/ui/component/dialog/GraphicsTab.kt index 3821efc905..feb92cf1fa 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/GraphicsTab.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/GraphicsTab.kt @@ -204,6 +204,17 @@ fun GraphicsTabContent(state: ContainerConfigState, default: Boolean = false) { state.config.value = config.copy(windowsVrEnabled = checked) }, ) + if (config.windowsVrEnabled) { + SettingsSwitch( + colors = settingsTileColorsAlt(), + title = { Text(text = stringResource(R.string.xr_open_composite_toggle)) }, + subtitle = { Text(text = stringResource(R.string.xr_open_composite_toggle_desc)) }, + state = config.openCompositeEnabled, + onCheckedChange = { checked -> + state.config.value = config.copy(openCompositeEnabled = checked) + }, + ) + } } SettingsListDropdown( colors = settingsTileColors(), diff --git a/app/src/main/java/app/gamenative/utils/ContainerUtils.kt b/app/src/main/java/app/gamenative/utils/ContainerUtils.kt index a5b128daa5..67574657c2 100644 --- a/app/src/main/java/app/gamenative/utils/ContainerUtils.kt +++ b/app/src/main/java/app/gamenative/utils/ContainerUtils.kt @@ -370,6 +370,7 @@ object ContainerUtils { // LSFG Vulkan frame generation lsfgEnabled = container.getExtra(LsfgVkManager.EXTRA_ARMED, "false").toBoolean(), windowsVrEnabled = container.getExtra("windowsVrEnabled", "false").toBoolean(), + openCompositeEnabled = container.getExtra("windowsVrOpenCompositeEnabled", "false").toBoolean(), ) } @@ -559,6 +560,7 @@ object ContainerUtils { // LSFG Vulkan frame generation container.putExtra(LsfgVkManager.EXTRA_ARMED, containerData.lsfgEnabled.toString()) container.putExtra("windowsVrEnabled", containerData.windowsVrEnabled.toString()) + container.putExtra("windowsVrOpenCompositeEnabled", containerData.openCompositeEnabled.toString()) try { container.language = containerData.language } catch (e: Exception) { diff --git a/app/src/main/java/com/winlator/container/ContainerData.kt b/app/src/main/java/com/winlator/container/ContainerData.kt index d3a325deef..52acaaf1ff 100644 --- a/app/src/main/java/com/winlator/container/ContainerData.kt +++ b/app/src/main/java/com/winlator/container/ContainerData.kt @@ -112,6 +112,7 @@ data class ContainerData( /** Whether LSFG frame generation is enabled for this container */ val lsfgEnabled: Boolean = false, val windowsVrEnabled: Boolean = false, + val openCompositeEnabled: Boolean = false, ) { companion object { val Saver = mapSaver( @@ -188,6 +189,7 @@ data class ContainerData( "sharpnessDenoise" to state.sharpnessDenoise, "lsfgEnabled" to state.lsfgEnabled, "windowsVrEnabled" to state.windowsVrEnabled, + "openCompositeEnabled" to state.openCompositeEnabled, ) }, restore = { savedMap -> @@ -263,6 +265,7 @@ data class ContainerData( sharpnessDenoise = (savedMap["sharpnessDenoise"] as? Int) ?: 100, lsfgEnabled = (savedMap["lsfgEnabled"] as? Boolean) ?: false, windowsVrEnabled = (savedMap["windowsVrEnabled"] as? Boolean) ?: false, + openCompositeEnabled = (savedMap["openCompositeEnabled"] as? Boolean) ?: false, ) }, ) diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index e4a32c7f94..6095374763 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -2479,5 +2479,7 @@ Reset gyro settings Run as VR app (experimental) For native VR titles such as Beat Saber. Needs arm64ec Wine and DXVK. Other games keep the flat immersive screen. + SteamVR (OpenVR) compatibility + Routes games built for SteamVR through OpenComposite. Turn on if the game says SteamVR is not running or stays flat with VR mode on. VR Render Scale From 161bb7f39c20e9bc9e0c239202621eb6f7e0b48d Mon Sep 17 00:00:00 2001 From: Utkarsh Dalal Date: Thu, 3 Sep 2026 21:10:52 +0530 Subject: [PATCH 25/46] Add translations for the VR mode and OpenComposite settings --- app/src/main/res/values-da/strings.xml | 4 ++++ app/src/main/res/values-de/strings.xml | 4 ++++ app/src/main/res/values-es/strings.xml | 4 ++++ app/src/main/res/values-fr/strings.xml | 4 ++++ app/src/main/res/values-it/strings.xml | 4 ++++ app/src/main/res/values-ja/strings.xml | 4 ++++ app/src/main/res/values-ko/strings.xml | 4 ++++ app/src/main/res/values-pl/strings.xml | 4 ++++ app/src/main/res/values-pt-rBR/strings.xml | 4 ++++ app/src/main/res/values-ro/strings.xml | 4 ++++ app/src/main/res/values-ru/strings.xml | 4 ++++ app/src/main/res/values-uk/strings.xml | 4 ++++ app/src/main/res/values-zh-rCN/strings.xml | 4 ++++ app/src/main/res/values-zh-rTW/strings.xml | 4 ++++ 14 files changed, 56 insertions(+) diff --git a/app/src/main/res/values-da/strings.xml b/app/src/main/res/values-da/strings.xml index 8adb5c3111..2312236fc1 100644 --- a/app/src/main/res/values-da/strings.xml +++ b/app/src/main/res/values-da/strings.xml @@ -2332,5 +2332,9 @@ %1$.1f°/s %1$d ms Nulstil gyroindstillinger + Kør som VR-app (eksperimentel) + Til native VR-titler som Beat Saber. Kræver arm64ec Wine og DXVK. Andre spil beholder den flade immersive skærm. + SteamVR (OpenVR)-kompatibilitet + Sender spil bygget til SteamVR gennem OpenComposite. Slå til, hvis spillet siger, at SteamVR ikke kører, eller forbliver fladt med VR-tilstand slået til. VR-gengivelsesskala diff --git a/app/src/main/res/values-de/strings.xml b/app/src/main/res/values-de/strings.xml index 96b715197f..aec190b8b8 100644 --- a/app/src/main/res/values-de/strings.xml +++ b/app/src/main/res/values-de/strings.xml @@ -2402,5 +2402,9 @@ %1$.1f°/s %1$d ms Gyro-Einstellungen zurücksetzen + Als VR-App ausführen (experimentell) + Für native VR-Titel wie Beat Saber. Benötigt arm64ec-Wine und DXVK. Andere Spiele behalten den flachen Immersiv-Bildschirm. + SteamVR-(OpenVR-)Kompatibilität + Leitet für SteamVR entwickelte Spiele über OpenComposite. Aktivieren, wenn das Spiel meldet, dass SteamVR nicht läuft, oder im VR-Modus flach bleibt. VR-Renderskalierung diff --git a/app/src/main/res/values-es/strings.xml b/app/src/main/res/values-es/strings.xml index 3fbec19af7..0d05ac73cc 100644 --- a/app/src/main/res/values-es/strings.xml +++ b/app/src/main/res/values-es/strings.xml @@ -2460,5 +2460,9 @@ %1$.1f°/s %1$d ms Restablecer ajustes del giroscopio + Ejecutar como app de VR (experimental) + Para títulos de VR nativos como Beat Saber. Requiere Wine arm64ec y DXVK. Los demás juegos mantienen la pantalla inmersiva plana. + Compatibilidad con SteamVR (OpenVR) + Redirige los juegos creados para SteamVR a través de OpenComposite. Actívalo si el juego dice que SteamVR no está en ejecución o se queda en plano con el modo VR activado. Escala de renderizado de RV diff --git a/app/src/main/res/values-fr/strings.xml b/app/src/main/res/values-fr/strings.xml index ea24b65baf..d4351bb432 100644 --- a/app/src/main/res/values-fr/strings.xml +++ b/app/src/main/res/values-fr/strings.xml @@ -2462,5 +2462,9 @@ %1$.1f°/s %1$d ms Réinitialiser les réglages du gyroscope + Lancer en tant qu’application VR (expérimental) + Pour les titres VR natifs comme Beat Saber. Nécessite Wine arm64ec et DXVK. Les autres jeux conservent l’écran immersif plat. + Compatibilité SteamVR (OpenVR) + Fait passer les jeux conçus pour SteamVR par OpenComposite. À activer si le jeu indique que SteamVR n’est pas lancé ou reste à plat avec le mode VR activé. Échelle de rendu VR diff --git a/app/src/main/res/values-it/strings.xml b/app/src/main/res/values-it/strings.xml index 3e14c2a4d8..48f20b31d0 100644 --- a/app/src/main/res/values-it/strings.xml +++ b/app/src/main/res/values-it/strings.xml @@ -2453,5 +2453,9 @@ %1$.1f°/s %1$d ms Ripristina impostazioni giroscopio + Esegui come app VR (sperimentale) + Per titoli VR nativi come Beat Saber. Richiede Wine arm64ec e DXVK. Gli altri giochi mantengono lo schermo immersivo piatto. + Compatibilità SteamVR (OpenVR) + Instrada i giochi creati per SteamVR tramite OpenComposite. Attivalo se il gioco segnala che SteamVR non è in esecuzione o resta piatto con la modalità VR attiva. Scala di rendering VR diff --git a/app/src/main/res/values-ja/strings.xml b/app/src/main/res/values-ja/strings.xml index 93510fe0aa..d9b58edd87 100644 --- a/app/src/main/res/values-ja/strings.xml +++ b/app/src/main/res/values-ja/strings.xml @@ -2415,5 +2415,9 @@ %1$.1f°/秒 %1$d ミリ秒 ジャイロ設定をリセット + VRアプリとして実行（試験的） + Beat SaberなどのネイティブVRタイトル向け。arm64ec WineとDXVKが必要です。その他のゲームは平面の没入型画面のままです。 + SteamVR（OpenVR）互換 + SteamVR向けに作られたゲームをOpenCompositeで動かします。ゲームがSteamVRが起動していないと表示する場合や、VRモードでも平面のままの場合に有効にしてください。 VRレンダースケール diff --git a/app/src/main/res/values-ko/strings.xml b/app/src/main/res/values-ko/strings.xml index 891814f5f4..6755f964a7 100644 --- a/app/src/main/res/values-ko/strings.xml +++ b/app/src/main/res/values-ko/strings.xml @@ -2456,5 +2456,9 @@ %1$.1f°/초 %1$d ms 자이로 설정 초기화 + VR 앱으로 실행 (실험적) + Beat Saber 같은 네이티브 VR 타이틀용입니다. arm64ec Wine과 DXVK가 필요합니다. 다른 게임은 평면 몰입형 화면을 유지합니다. + SteamVR(OpenVR) 호환 + SteamVR용으로 만들어진 게임을 OpenComposite를 통해 실행합니다. 게임이 SteamVR이 실행 중이 아니라고 표시하거나 VR 모드에서도 평면으로 남아 있으면 켜세요. VR 렌더링 배율 diff --git a/app/src/main/res/values-pl/strings.xml b/app/src/main/res/values-pl/strings.xml index 0585238d76..f122cd39a0 100644 --- a/app/src/main/res/values-pl/strings.xml +++ b/app/src/main/res/values-pl/strings.xml @@ -2468,5 +2468,9 @@ %1$.1f°/s %1$d ms Resetuj ustawienia żyroskopu + Uruchom jako aplikację VR (eksperymentalne) + Dla natywnych tytułów VR, takich jak Beat Saber. Wymaga Wine arm64ec i DXVK. Pozostałe gry zachowują płaski ekran immersyjny. + Zgodność ze SteamVR (OpenVR) + Kieruje gry stworzone dla SteamVR przez OpenComposite. Włącz, jeśli gra zgłasza, że SteamVR nie działa, lub pozostaje płaska przy włączonym trybie VR. Skala renderowania VR diff --git a/app/src/main/res/values-pt-rBR/strings.xml b/app/src/main/res/values-pt-rBR/strings.xml index 9f46a07b68..bdd7543bff 100644 --- a/app/src/main/res/values-pt-rBR/strings.xml +++ b/app/src/main/res/values-pt-rBR/strings.xml @@ -2332,5 +2332,9 @@ %1$.1f°/s %1$d ms Redefinir configurações do giroscópio + Executar como app de VR (experimental) + Para títulos de VR nativos como Beat Saber. Requer Wine arm64ec e DXVK. Os demais jogos mantêm a tela imersiva plana. + Compatibilidade com SteamVR (OpenVR) + Roteia jogos feitos para SteamVR pelo OpenComposite. Ative se o jogo disser que o SteamVR não está em execução ou continuar plano com o modo VR ativado. Escala de renderização de VR diff --git a/app/src/main/res/values-ro/strings.xml b/app/src/main/res/values-ro/strings.xml index 471a68ad34..3843c6a865 100644 --- a/app/src/main/res/values-ro/strings.xml +++ b/app/src/main/res/values-ro/strings.xml @@ -2467,5 +2467,9 @@ %1$.1f°/s %1$d ms Resetează setările giroscopului + Rulează ca aplicație VR (experimental) + Pentru titluri VR native precum Beat Saber. Necesită Wine arm64ec și DXVK. Celelalte jocuri păstrează ecranul imersiv plat. + Compatibilitate SteamVR (OpenVR) + Direcționează jocurile create pentru SteamVR prin OpenComposite. Activează dacă jocul spune că SteamVR nu rulează sau rămâne plat cu modul VR pornit. Scară de randare VR diff --git a/app/src/main/res/values-ru/strings.xml b/app/src/main/res/values-ru/strings.xml index 08948be8a5..f1d33aba0b 100644 --- a/app/src/main/res/values-ru/strings.xml +++ b/app/src/main/res/values-ru/strings.xml @@ -2396,5 +2396,9 @@ https://gamenative.app %1$.1f°/с %1$d мс Сбросить настройки гироскопа + Запускать как VR-приложение (экспериментально) + Для нативных VR-игр, таких как Beat Saber. Требуются Wine arm64ec и DXVK. Остальные игры сохраняют плоский иммерсивный экран. + Совместимость со SteamVR (OpenVR) + Запускает игры, созданные для SteamVR, через OpenComposite. Включите, если игра сообщает, что SteamVR не запущен, или остаётся плоской при включённом VR-режиме. Масштаб рендеринга VR diff --git a/app/src/main/res/values-uk/strings.xml b/app/src/main/res/values-uk/strings.xml index 8a8138539a..7a601f1a79 100644 --- a/app/src/main/res/values-uk/strings.xml +++ b/app/src/main/res/values-uk/strings.xml @@ -2464,5 +2464,9 @@ %1$.1f°/с %1$d мс Скинути налаштування гіроскопа + Запускати як VR-застосунок (експериментально) + Для нативних VR-ігор, як-от Beat Saber. Потрібні Wine arm64ec і DXVK. Інші ігри зберігають плаский імерсивний екран. + Сумісність зі SteamVR (OpenVR) + Запускає ігри, створені для SteamVR, через OpenComposite. Увімкніть, якщо гра повідомляє, що SteamVR не запущено, або залишається пласкою з увімкненим VR-режимом. Масштаб рендерингу VR diff --git a/app/src/main/res/values-zh-rCN/strings.xml b/app/src/main/res/values-zh-rCN/strings.xml index eed3544971..fc5136d9d0 100644 --- a/app/src/main/res/values-zh-rCN/strings.xml +++ b/app/src/main/res/values-zh-rCN/strings.xml @@ -2476,5 +2476,9 @@ %1$.1f°/秒 %1$d 毫秒 重置陀螺仪设置 + 以 VR 应用运行（实验性） + 适用于 Beat Saber 等原生 VR 游戏。需要 arm64ec Wine 和 DXVK。其他游戏仍使用平面沉浸式屏幕。 + SteamVR (OpenVR) 兼容 + 通过 OpenComposite 运行为 SteamVR 开发的游戏。若游戏提示 SteamVR 未运行，或开启 VR 模式后仍为平面显示，请开启此项。 VR 渲染比例 diff --git a/app/src/main/res/values-zh-rTW/strings.xml b/app/src/main/res/values-zh-rTW/strings.xml index bff2b7034f..0a3cd2deae 100644 --- a/app/src/main/res/values-zh-rTW/strings.xml +++ b/app/src/main/res/values-zh-rTW/strings.xml @@ -2467,5 +2467,9 @@ %1$.1f°/秒 %1$d 毫秒 重設陀螺儀設定 + 以 VR 應用程式執行（實驗性） + 適用於 Beat Saber 等原生 VR 遊戲。需要 arm64ec Wine 與 DXVK。其他遊戲仍使用平面沉浸式畫面。 + SteamVR (OpenVR) 相容 + 透過 OpenComposite 執行為 SteamVR 開發的遊戲。若遊戲提示 SteamVR 未執行，或開啟 VR 模式後仍為平面顯示，請開啟此項。 VR 算繪比例 From 2bc6cb1a1b111ba5a66cd1976ff7d3e541f66a36 Mon Sep 17 00:00:00 2001 From: Utkarsh Dalal Date: Thu, 3 Sep 2026 22:02:33 +0530 Subject: [PATCH 26/46] Move the VR mode toggle next to the immersive launch toggle on the game page --- .../ui/component/dialog/GraphicsTab.kt | 9 ---- .../ui/screen/library/LibraryAppScreen.kt | 24 +++++++++++ .../screen/library/appscreen/BaseAppScreen.kt | 43 +++++++++++++++---- 3 files changed, 58 insertions(+), 18 deletions(-) diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/GraphicsTab.kt b/app/src/main/java/app/gamenative/ui/component/dialog/GraphicsTab.kt index feb92cf1fa..7bddbe1874 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/GraphicsTab.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/GraphicsTab.kt @@ -195,15 +195,6 @@ fun GraphicsTabContent(state: ContainerConfigState, default: Boolean = false) { ) Text(text = "${config.xrRenderScale}%") } - SettingsSwitch( - colors = settingsTileColorsAlt(), - title = { Text(text = stringResource(R.string.xr_windows_vr_toggle)) }, - subtitle = { Text(text = stringResource(R.string.xr_windows_vr_toggle_desc)) }, - state = config.windowsVrEnabled, - onCheckedChange = { checked -> - state.config.value = config.copy(windowsVrEnabled = checked) - }, - ) if (config.windowsVrEnabled) { SettingsSwitch( colors = settingsTileColorsAlt(), diff --git a/app/src/main/java/app/gamenative/ui/screen/library/LibraryAppScreen.kt b/app/src/main/java/app/gamenative/ui/screen/library/LibraryAppScreen.kt index 1d67adcce8..0668a26282 100644 --- a/app/src/main/java/app/gamenative/ui/screen/library/LibraryAppScreen.kt +++ b/app/src/main/java/app/gamenative/ui/screen/library/LibraryAppScreen.kt @@ -519,6 +519,8 @@ internal data class ImmersiveModeUiState( val isSupported: Boolean = false, val isEnabled: Boolean = false, val onChange: (Boolean) -> Unit = {}, + val isVrEnabled: Boolean = false, + val onVrChange: (Boolean) -> Unit = {}, ) @Composable @@ -976,6 +978,28 @@ internal fun AppScreenContent( color = Color.White, ) } + if (immersiveMode.isEnabled) { + Row( + modifier = Modifier + .fillMaxWidth() + .padding(start = 24.dp) + .clickable { immersiveMode.onVrChange(!immersiveMode.isVrEnabled) }, + verticalAlignment = Alignment.CenterVertically, + ) { + Checkbox( + checked = immersiveMode.isVrEnabled, + onCheckedChange = immersiveMode.onVrChange, + colors = CheckboxDefaults.colors( + uncheckedColor = Color.White.copy(alpha = 0.7f), + ), + ) + Text( + text = stringResource(R.string.xr_windows_vr_toggle), + style = MaterialTheme.typography.bodyMedium, + color = Color.White, + ) + } + } } if (isDownloading && isPortrait) { diff --git a/app/src/main/java/app/gamenative/ui/screen/library/appscreen/BaseAppScreen.kt b/app/src/main/java/app/gamenative/ui/screen/library/appscreen/BaseAppScreen.kt index 0fd714903e..6386bd5330 100644 --- a/app/src/main/java/app/gamenative/ui/screen/library/appscreen/BaseAppScreen.kt +++ b/app/src/main/java/app/gamenative/ui/screen/library/appscreen/BaseAppScreen.kt @@ -157,6 +157,7 @@ internal suspend fun installMissingComponentsForConfig( abstract class BaseAppScreen { companion object { + private const val WINDOWS_VR_ENABLED_EXTRA = "windowsVrEnabled" private val installDialogStates = mutableStateMapOf() private val exportConfigRequests = mutableStateMapOf() private val importConfigRequests = mutableStateMapOf() @@ -1255,22 +1256,41 @@ abstract class BaseAppScreen { app.gamenative.BuildConfig.XR_BUILD && app.gamenative.MainActivity.isHeadset(context) } var isImmersiveModeEnabledState by remember(libraryItem.appId) { mutableStateOf(null) } + var isVrModeEnabledState by remember(libraryItem.appId) { mutableStateOf(false) } val immersiveModeSaveRequests = remember(libraryItem.appId) { Channel(Channel.CONFLATED) } + val vrModeSaveRequests = remember(libraryItem.appId) { Channel(Channel.CONFLATED) } if (isImmersiveModeSupported) { LaunchedEffect(libraryItem.appId) { val stored = withContext(Dispatchers.IO) { - runCatching { ContainerUtils.getContainer(context, libraryItem.appId).isLaunchImmersiveMode() } - .getOrDefault(true) + runCatching { + val container = ContainerUtils.getContainer(context, libraryItem.appId) + container.isLaunchImmersiveMode() to + container.getExtra(WINDOWS_VR_ENABLED_EXTRA, "false").toBoolean() + }.getOrDefault(true to false) } if (isImmersiveModeEnabledState == null) { - isImmersiveModeEnabledState = stored + isImmersiveModeEnabledState = stored.first + isVrModeEnabledState = stored.second } - for (enabled in immersiveModeSaveRequests) { - withContext(Dispatchers.IO) { - runCatching { - val container = ContainerUtils.getContainer(context, libraryItem.appId) - container.setLaunchImmersiveMode(enabled) - container.saveData() + launch { + for (enabled in immersiveModeSaveRequests) { + withContext(Dispatchers.IO) { + runCatching { + val container = ContainerUtils.getContainer(context, libraryItem.appId) + container.setLaunchImmersiveMode(enabled) + container.saveData() + } + } + } + } + launch { + for (enabled in vrModeSaveRequests) { + withContext(Dispatchers.IO) { + runCatching { + val container = ContainerUtils.getContainer(context, libraryItem.appId) + container.putExtra(WINDOWS_VR_ENABLED_EXTRA, enabled.toString()) + container.saveData() + } } } } @@ -1609,6 +1629,11 @@ abstract class BaseAppScreen { isImmersiveModeEnabledState = enabled immersiveModeSaveRequests.trySend(enabled) }, + isVrEnabled = isVrModeEnabledState, + onVrChange = { enabled -> + isVrModeEnabledState = enabled + vrModeSaveRequests.trySend(enabled) + }, ), onDownloadInstallClick = { if (app.gamenative.launch.LaunchReadiness.pending) { From afe8db660c9e44f67932adf43384d03e71f471d3 Mon Sep 17 00:00:00 2001 From: Utkarsh Dalal Date: Thu, 3 Sep 2026 22:20:43 +0530 Subject: [PATCH 27/46] Keep the game in the foreground when the launcher pauses behind the immersive activity --- app/src/main/java/app/gamenative/MainActivity.kt | 5 +++++ app/src/main/java/app/gamenative/PluviaApp.kt | 1 + .../java/app/gamenative/ui/screen/xr/ImmersiveXrActivity.kt | 2 ++ 3 files changed, 8 insertions(+) diff --git a/app/src/main/java/app/gamenative/MainActivity.kt b/app/src/main/java/app/gamenative/MainActivity.kt index 611bf79795..ac4106fdf4 100644 --- a/app/src/main/java/app/gamenative/MainActivity.kt +++ b/app/src/main/java/app/gamenative/MainActivity.kt @@ -552,6 +552,11 @@ class MainActivity : ComponentActivity() { } override fun onPause() { + if (PluviaApp.isImmersiveActivityResumed) { + Timber.d("Launcher paused behind the immersive activity; game stays in the foreground") + super.onPause() + return + } PowerManager.pause() PluviaApp.isActivityInForeground = false if (hasReadyGameLifecycleState("pause")) { diff --git a/app/src/main/java/app/gamenative/PluviaApp.kt b/app/src/main/java/app/gamenative/PluviaApp.kt index 6bc60c5985..2286ec5b81 100644 --- a/app/src/main/java/app/gamenative/PluviaApp.kt +++ b/app/src/main/java/app/gamenative/PluviaApp.kt @@ -224,6 +224,7 @@ class PluviaApp : SplitCompatApplication() { var isOverlayPaused by mutableStateOf(false) @Volatile var isActivityInForeground: Boolean = true + var isImmersiveActivityResumed: Boolean = false // Active runtime suspend policy for the current in-game session. var activeSuspendPolicy: String = Container.SUSPEND_POLICY_MANUAL diff --git a/app/src/main/java/app/gamenative/ui/screen/xr/ImmersiveXrActivity.kt b/app/src/main/java/app/gamenative/ui/screen/xr/ImmersiveXrActivity.kt index e67f761488..3c0ddfd8ea 100644 --- a/app/src/main/java/app/gamenative/ui/screen/xr/ImmersiveXrActivity.kt +++ b/app/src/main/java/app/gamenative/ui/screen/xr/ImmersiveXrActivity.kt @@ -457,6 +457,7 @@ class ImmersiveXrActivity : androidx.activity.ComponentActivity() { override fun onResume() { super.onResume() + PluviaApp.isImmersiveActivityResumed = true PluviaApp.isActivityInForeground = true if (SteamService.keepAlive && PluviaApp.hasValidSuspendPolicyState() && PluviaApp.xEnvironment != null) { when { @@ -469,6 +470,7 @@ class ImmersiveXrActivity : androidx.activity.ComponentActivity() { } override fun onPause() { + PluviaApp.isImmersiveActivityResumed = false PluviaApp.isActivityInForeground = false Timber.i( "Immersive: onPause, isFinishing=%b isChangingConfigurations=%b", From 51abcd80a9a98a2b0b479d5e147dce7b50078989 Mon Sep 17 00:00:00 2001 From: Utkarsh Dalal Date: Thu, 3 Sep 2026 22:41:55 +0530 Subject: [PATCH 28/46] Ship the Windows VR payload in the modernXr assets --- app/build.gradle.kts | 2 +- .../assets/gamenative_openxr_runtime32.dll | Bin 0 -> 76800 bytes .../assets/gamenative_openxr_runtime64.dll | Bin 0 -> 76288 bytes .../assets/gamenative_xr_unixbridge.dll | Bin 0 -> 1048576 bytes .../assets/gamenative_xr_unixbridge.so | Bin 0 -> 319392 bytes .../gamenative_xr_unixbridge.wine-commit | 1 + .../assets/gamenative_xr_unixbridge32.dll | Bin 0 -> 41706 bytes app/src/modernXr/assets/opencomposite_x64.dll | Bin 0 -> 1930752 bytes app/src/modernXr/assets/payload.version | 1 + tools/build-windows-xr-runtime.ps1 | 2 +- tools/build-xr-native.ps1 | 2 +- tools/build-xr-payload-macos.sh | 4 ++-- tools/provision-build-arm64x-wine-bridge.sh | 2 +- tools/stage-opencomposite.ps1 | 2 +- tools/stage-wine-xr-bridge.ps1 | 2 +- tools/verify-xr-payload.ps1 | 2 +- 16 files changed, 11 insertions(+), 9 deletions(-) create mode 100755 app/src/modernXr/assets/gamenative_openxr_runtime32.dll create mode 100755 app/src/modernXr/assets/gamenative_openxr_runtime64.dll create mode 100755 app/src/modernXr/assets/gamenative_xr_unixbridge.dll create mode 100755 app/src/modernXr/assets/gamenative_xr_unixbridge.so create mode 100644 app/src/modernXr/assets/gamenative_xr_unixbridge.wine-commit create mode 100644 app/src/modernXr/assets/gamenative_xr_unixbridge32.dll create mode 100644 app/src/modernXr/assets/opencomposite_x64.dll create mode 100644 app/src/modernXr/assets/payload.version diff --git a/app/build.gradle.kts b/app/build.gradle.kts index bb4e25a49d..310cbc2935 100644 --- a/app/build.gradle.kts +++ b/app/build.gradle.kts @@ -268,7 +268,7 @@ android { } getByName("modernXr") { assets { - srcDirs("src/modern/assets", "src/main/assets", "build/generated/xrPayload/modernXr") + srcDirs("src/modern/assets", "src/main/assets") } jniLibs { setSrcDirs(listOf("src/modern/jniLibs", "build/generated/xrNative/modernXr")) diff --git a/app/src/modernXr/assets/gamenative_openxr_runtime32.dll b/app/src/modernXr/assets/gamenative_openxr_runtime32.dll new file mode 100755 index 0000000000000000000000000000000000000000..21ef7c40abb4f5d9078d7696b7106fbf22020ba7 GIT binary patch literal 76800 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μ!XFG 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 literal 0 HcmV?d00001 diff --git a/app/src/modernXr/assets/gamenative_xr_unixbridge.dll b/app/src/modernXr/assets/gamenative_xr_unixbridge.dll new file mode 100755 index 0000000000000000000000000000000000000000..b8da8b4f9cdc5e9a4925a78555a3631150f73932 GIT binary patch literal 1048576 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 literal 0 HcmV?d00001 diff --git a/app/src/modernXr/assets/gamenative_xr_unixbridge.so b/app/src/modernXr/assets/gamenative_xr_unixbridge.so new file mode 100755 index 0000000000000000000000000000000000000000..455c965531af53a70aac2e89654e02b1b6b50fc3 GIT binary patch literal 319392 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�m5q@@4A5K7XFw5)z?0%c0TipYv493Tvc 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 F|9_yapUwaP literal 0 HcmV?d00001 diff --git a/app/src/modernXr/assets/gamenative_xr_unixbridge.wine-commit b/app/src/modernXr/assets/gamenative_xr_unixbridge.wine-commit new file mode 100644 index 0000000000..0c13c2e787 --- /dev/null +++ b/app/src/modernXr/assets/gamenative_xr_unixbridge.wine-commit @@ -0,0 +1 @@ +77eed5501e077f5f0422d063b171a3a4491f52a6 diff --git a/app/src/modernXr/assets/gamenative_xr_unixbridge32.dll b/app/src/modernXr/assets/gamenative_xr_unixbridge32.dll new file mode 100644 index 0000000000000000000000000000000000000000..54762881b3aa6f79e0d0c38c54895946e679e697 GIT binary patch literal 41706 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 zæL*05X>p!mc>!qN=DW$Ic&-P+AsLst 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≶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 Date: Thu, 3 Sep 2026 22:44:19 +0530 Subject: [PATCH 29/46] Ship libxrimmersive.so built from the branch and keep the modernXr jniLibs source set --- app/build.gradle.kts | 2 +- .../jniLibs/arm64-v8a/libxrimmersive.so | Bin 1812504 -> 1807288 bytes tools/build-xr-native.ps1 | 2 +- tools/build-xr-payload-macos.sh | 14 ++++++++++++++ 4 files changed, 16 insertions(+), 2 deletions(-) diff --git a/app/build.gradle.kts b/app/build.gradle.kts index 310cbc2935..a9bf87f125 100644 --- a/app/build.gradle.kts +++ b/app/build.gradle.kts @@ -271,7 +271,7 @@ android { srcDirs("src/modern/assets", "src/main/assets") } jniLibs { - setSrcDirs(listOf("src/modern/jniLibs", "build/generated/xrNative/modernXr")) + setSrcDirs(listOf("src/modern/jniLibs", "src/modernXr/jniLibs")) } } getByName("debug") { diff --git a/app/src/modernXr/jniLibs/arm64-v8a/libxrimmersive.so b/app/src/modernXr/jniLibs/arm64-v8a/libxrimmersive.so index f92c95c98e735e5c082d2f27fd5bd46344fad32e..44dd28a587299256bcc12dca45740d065bb28c9b 100755 GIT binary patch literal 1807288 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 +d^_$I5!L>CPa@{ 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 z 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 z