mirror of
https://github.com/saphid/frame-control.git
synced 2026-10-06 14:00:34 +02:00
Add APK-local OpenXR 1.1 compatibility layer for Frame
This commit is contained in:
saphid committed
1 parent
724b020e93
commit
0dbe18d824
21 files changed
+17204
No files matched your search
@@ -0,0 +1,2 @@
|
||||
# Preserve upstream headers byte-for-byte, including their existing whitespace.
|
||||
vendor/** -whitespace
|
||||
@@ -0,0 +1 @@
|
||||
/build-*/
|
||||
@@ -0,0 +1,25 @@
|
||||
cmake_minimum_required(VERSION 3.22)
|
||||
project(FrameXrCompat LANGUAGES CXX)
|
||||
set(CMAKE_CXX_STANDARD 17)
|
||||
set(CMAKE_CXX_STANDARD_REQUIRED ON)
|
||||
add_library(compat_logic INTERFACE)
|
||||
target_include_directories(compat_logic INTERFACE . vendor)
|
||||
if(ANDROID)
|
||||
add_library(XrApiLayer_FRAME_compat SHARED layer.cpp)
|
||||
target_link_libraries(XrApiLayer_FRAME_compat PRIVATE compat_logic log)
|
||||
target_compile_definitions(XrApiLayer_FRAME_compat PRIVATE XR_USE_PLATFORM_ANDROID XR_NO_PROTOTYPES)
|
||||
target_compile_options(XrApiLayer_FRAME_compat PRIVATE -O2 -fvisibility=hidden -Wall -Wextra -Werror)
|
||||
target_link_options(XrApiLayer_FRAME_compat PRIVATE -Wl,-z,max-page-size=16384 -Wl,--no-undefined -Wl,--exclude-libs,ALL -Wl,-s)
|
||||
else()
|
||||
enable_testing()
|
||||
add_executable(compat_tests tests/compat_tests.cpp)
|
||||
target_link_libraries(compat_tests PRIVATE compat_logic)
|
||||
target_compile_options(compat_tests PRIVATE -Wall -Wextra -Werror)
|
||||
add_test(NAME compat_logic COMMAND compat_tests)
|
||||
add_executable(dispatch_tests tests/dispatch_tests.cpp)
|
||||
target_link_libraries(dispatch_tests PRIVATE compat_logic)
|
||||
target_include_directories(dispatch_tests PRIVATE tests/shims)
|
||||
target_compile_definitions(dispatch_tests PRIVATE XR_USE_PLATFORM_ANDROID XR_NO_PROTOTYPES)
|
||||
target_compile_options(dispatch_tests PRIVATE -Wall -Wextra -Werror)
|
||||
add_test(NAME layer_dispatch COMMAND dispatch_tests)
|
||||
endif()
|
||||
@@ -0,0 +1,254 @@
|
||||
# Frame OpenXR compatibility API layer
|
||||
|
||||
`XR_APILAYER_FRAME_compat` is an APK-local implicit API layer for Steam Frame's
|
||||
OpenXR 1.0 Android runtime. It translates selected 1.1 functionality; it is not
|
||||
a conformant replacement for a complete 1.1 runtime. Device facts are in
|
||||
[../../docs/vr-apks.md](../../docs/vr-apks.md). No headset was contacted during
|
||||
implementation. Loading, Valve-layer coexistence, controller usability, and
|
||||
Wolvic startup/rendering on Lepton remain **unverified on device**.
|
||||
|
||||
## Behavior
|
||||
|
||||
- The negotiated `createApiLayerInstance` hook handles `xrCreateInstance`.
|
||||
API requests >= 1.1 become `XR_API_VERSION_1_0` (1.0.63 with these headers),
|
||||
rather than carrying an arbitrary application's patch into the 1.0 request.
|
||||
Requests below 1.1 are unchanged. The loader may reject future API versions
|
||||
before any layer runs.
|
||||
- Enumerate downstream extensions through the **next layer's** GIPA before
|
||||
creation. Only advertised promoted extensions are added, with duplicates
|
||||
removed. All other application extensions remain, except the two stubs below.
|
||||
Log added, stubbed and missing extensions with tag `FrameXrCompat`.
|
||||
- Missing `XR_KHR_android_thread_settings` is advertised and accepted;
|
||||
`xrSetAndroidApplicationThreadKHR` logs and returns success without changing
|
||||
thread scheduling. Missing `XR_OCULUS_android_session_state_enable` is
|
||||
advertised and accepted, with no commands or additional session behavior.
|
||||
If downstream supports either extension, preserve it and its real commands.
|
||||
Stubbing these capabilities is intentionally limited to accepting the app's
|
||||
request; it does not provide Meta services.
|
||||
- The manifest's `instance_extensions` makes both stubs visible during the
|
||||
loader's pre-instance enumeration and validation. The layer also exposes
|
||||
an enumeration implementation with count/capacity handling. Before a next
|
||||
dispatch is available it can enumerate only its own extensions; normal app
|
||||
global enumeration is performed by the loader, merging runtime and manifest
|
||||
entries. See [loader_core.cpp L106–145](https://github.com/KhronosGroup/OpenXR-SDK-Source/blob/release-1.1.63/src/loader/loader_core.cpp#L106)
|
||||
and [manifest parsing L549–558](https://github.com/KhronosGroup/OpenXR-SDK-Source/blob/release-1.1.63/src/loader/manifest_file.cpp#L549).
|
||||
- Unknown missing extensions are never silently removed. Khronos may reject
|
||||
them **before** entering the layer and name them in `OpenXR-Loader` logs
|
||||
([loader_instance.cpp L149–176](https://github.com/KhronosGroup/OpenXR-SDK-Source/blob/release-1.1.63/src/loader/loader_instance.cpp#L149)).
|
||||
If they reach this layer, it logs their names and preserves them for the
|
||||
downstream failure.
|
||||
- `xrLocateSpaces` dispatches to `xrLocateSpacesKHR` per session/instance.
|
||||
This is the only command added in 1.1. The three relevant structure types
|
||||
(`SPACES_LOCATE_INFO`, `SPACE_LOCATIONS`, `SPACE_VELOCITIES`) and their KHR
|
||||
versions are **numeric aliases**, and the structs are typedef aliases in
|
||||
these headers. Explicit type conversion of local input/output copies is
|
||||
therefore an identity conversion; the velocity chain passes through without
|
||||
mutating its types or linkage. Output arrays remain shared and receive the
|
||||
runtime's results, including on error; caller struct headers remain intact.
|
||||
- With palm pose enabled, rewrite both hand paths ending in
|
||||
`/input/grip_surface/pose` to `/input/palm_ext/pose` in `xrStringToPath` and
|
||||
in binding suggestions (including paths obtained before this layer rewrote
|
||||
them). Unknown paths are left alone.
|
||||
- `xrGetInstanceProperties` and unrelated commands pass through. The real
|
||||
runtime's identity is not spoofed. Dispatch tables and session ownership are
|
||||
locked, and removed after successful destruction. Downstream calls occur
|
||||
outside the lock.
|
||||
|
||||
## Spec basis and interaction profiles
|
||||
|
||||
The pinned [1.1 promotions appendix, versions.adoc L16–156](https://github.com/KhronosGroup/OpenXR-Docs/blob/release-1.1.63/specification/sources/chapters/versions.adoc#L16)
|
||||
includes a generated promotion list. Its source is the
|
||||
[1.1.63 XML registry](https://github.com/KhronosGroup/OpenXR-Docs/blob/release-1.1.63/specification/registry/xr.xml),
|
||||
selecting `extension[@promotedto='XR_VERSION_1_1']`. The full list implemented:
|
||||
|
||||
| Promoted extension | Handling |
|
||||
| --- | --- |
|
||||
| `XR_KHR_locate_spaces` | Enable if advertised; core command alias |
|
||||
| `XR_EXT_local_floor` | Enable if advertised; reference-space enum is an alias |
|
||||
| `XR_EXT_uuid` | Enable if advertised; type alias, no commands |
|
||||
| `XR_EXT_palm_pose` | Enable if advertised; rewrite grip-surface paths |
|
||||
| `XR_VARJO_quad_views` | Enable if advertised; view-configuration enum alias, support remains optional |
|
||||
| `XR_EXT_samsung_odyssey_controller` | Enable if advertised |
|
||||
| `XR_EXT_hp_mixed_reality_controller` | Enable if advertised |
|
||||
| `XR_HTC_vive_cosmos_controller_interaction` | Enable if advertised |
|
||||
| `XR_HTC_vive_focus3_controller_interaction` | Enable if advertised |
|
||||
| `XR_ML_ml2_controller_interaction` | Enable if advertised |
|
||||
| `XR_FB_touch_controller_pro` | Enable if advertised; old profile still usable |
|
||||
| `XR_META_touch_controller_plus` | Enable if advertised; old profile still usable |
|
||||
| `XR_BD_controller_interaction` | Enable if advertised |
|
||||
| `XR_KHR_maintenance1` | Enable if advertised (included in the pinned registry's promotion list) |
|
||||
|
||||
`XR_EXT_hand_interaction` is **not** promoted to 1.1. Preserve it if requested;
|
||||
it is not auto-enabled merely because the runtime advertises it. The parent
|
||||
provided its availability; the device notes list extensions non-exhaustively.
|
||||
|
||||
The registry's `XR_VERSION_1_1` feature introduces 13 profile paths. For
|
||||
Samsung Odyssey, HP mixed reality, HTC Cosmos/Focus3, ML2 and the three
|
||||
ByteDance Pico profiles, drop a whole suggestion call with success when the
|
||||
corresponding extension is absent. Keep it when the extension is enabled.
|
||||
Drop the five new Meta paths: `touch_pro_controller`, `touch_plus_controller`,
|
||||
`touch_controller_rift_cv1`, `touch_controller_quest_1_rift_s`, and
|
||||
`touch_controller_quest_2`. The verified runtime notes do not list these;
|
||||
Pro/Plus promotion also renames several components, so the old extension's
|
||||
presence alone does not prove support for the new profile. This layer does
|
||||
not implement those component conversions. Existing old Pro/Plus profile
|
||||
paths are passed through if the app uses them.
|
||||
|
||||
Preserve the documented `oculus/touch_controller`, `khr/simple_controller`,
|
||||
`valve/frame_controller` and original PC profile paths. The notes' "usual PC
|
||||
controllers" is not a complete enumerated list: availability of promoted PC
|
||||
profiles is inferred from the runtime's extension advertisement, not invented
|
||||
from that phrase. OpenXR has no general profile enumeration API. Dropping
|
||||
suggestions prevents an unsupported 1.1 profile from aborting initialization;
|
||||
it does not create bindings, so the app must also suggest a supported fallback.
|
||||
|
||||
## Headers and licensing
|
||||
|
||||
The required public headers (`openxr.h`, `openxr_platform.h`,
|
||||
`openxr_platform_defines.h`) are unmodified from
|
||||
[OpenXR-SDK release-1.1.63](https://github.com/KhronosGroup/OpenXR-SDK/tree/release-1.1.63/include/openxr),
|
||||
commit [f2448a8](https://github.com/KhronosGroup/OpenXR-SDK/commit/f2448a8797c85814aa892efc1ab8707900fbcc78).
|
||||
The requested filename `loader_interfaces.h` no longer exists in 1.1 SDK
|
||||
releases: negotiation was ratified and moved to `openxr_loader_negotiation.h`
|
||||
in 1.0.33 ([spec history L166–186](https://github.com/KhronosGroup/OpenXR-Docs/blob/release-1.1.63/specification/sources/chapters/versions.adoc#L166)).
|
||||
To retain that requested interface filename, the layer uses the unmodified,
|
||||
ABI-compatible [last legacy header from SDK-Source release-1.0.32](https://github.com/KhronosGroup/OpenXR-SDK-Source/blob/release-1.0.32/src/common/loader_interfaces.h).
|
||||
Only these four headers are vendored. They offer Apache-2.0 OR MIT; this
|
||||
vendoring uses Apache-2.0, reproduced in [vendor/LICENSE](vendor/LICENSE).
|
||||
|
||||
## Android discovery and coexistence
|
||||
|
||||
**Minimum asset-discovery loader release: 1.0.25 (2022-09-02).** Its
|
||||
[release commit, 15c3d8e](https://github.com/KhronosGroup/OpenXR-SDK-Source/commit/15c3d8eb99994e5365d6b6f96eefaf4c51a65a9d)
|
||||
explicitly announces APK-packaged API layers;
|
||||
[manifest_file.cpp L665–723](https://github.com/KhronosGroup/OpenXR-SDK-Source/blob/release-1.0.25/src/loader/manifest_file.cpp#L665)
|
||||
implements discovery, and [L934–940](https://github.com/KhronosGroup/OpenXR-SDK-Source/blob/release-1.0.25/src/loader/manifest_file.cpp#L934)
|
||||
adds asset manifests after filesystem manifests. This is not a 1.1-only feature.
|
||||
|
||||
**For an app requesting API 1.1, use a 1.1 loader (first release 1.1.36) or
|
||||
newer.** A 1.0 loader rejects the request before the layer can downgrade it;
|
||||
see [loader_core.cpp L217–230](https://github.com/KhronosGroup/OpenXR-SDK-Source/blob/release-1.1.63/src/loader/loader_core.cpp#L217).
|
||||
The runtime can remain 1.0.
|
||||
|
||||
Source inspection at release-1.1.63 confirms:
|
||||
|
||||
- [manifest_file.cpp L720–783](https://github.com/KhronosGroup/OpenXR-SDK-Source/blob/release-1.1.63/src/loader/manifest_file.cpp#L720)
|
||||
uses the initialized Android asset manager and scans
|
||||
`openxr/1/api_layers/implicit.d/` for JSON. The application must initialize
|
||||
the loader with its Android context (`xrInitializeLoaderKHR`). In the APK,
|
||||
the entry is `assets/openxr/1/api_layers/implicit.d/XrApiLayer_FRAME_compat.json`.
|
||||
- A bare `library_path`, as used here, is **not explicitly concatenated** with
|
||||
`nativeLibraryDir`. [L878–900](https://github.com/KhronosGroup/OpenXR-SDK-Source/blob/release-1.1.63/src/loader/manifest_file.cpp#L878)
|
||||
leaves a bare name for normal dynamic-linker search in the application's
|
||||
namespace (including its native library directory). Relative paths with a
|
||||
slash use [LocateLibraryInAssets L943–952](https://github.com/KhronosGroup/OpenXR-SDK-Source/blob/release-1.1.63/src/loader/manifest_file.cpp#L943),
|
||||
which resolves against `GetAndroidNativeLibraryDir()`.
|
||||
[loader_init_data.cpp L87–96](https://github.com/KhronosGroup/OpenXR-SDK-Source/blob/release-1.1.63/src/loader/loader_init_data.cpp#L87)
|
||||
obtains the asset manager and `ApplicationInfo.nativeLibraryDir` via JNI.
|
||||
Wolvic's supplied manifest has `android:extractNativeLibs="true"`.
|
||||
- [android_utilities.cpp L267–322](https://github.com/KhronosGroup/OpenXR-SDK-Source/blob/release-1.1.63/src/loader/android_utilities.cpp#L267)
|
||||
handles runtime broker discovery, not APK layer discovery. Its
|
||||
`native_lib_dir + so_filename` and `dlopen` refer to the runtime package.
|
||||
They must not be confused with the app's layer library resolution.
|
||||
- [manifest_file.cpp L1008–1023](https://github.com/KhronosGroup/OpenXR-SDK-Source/blob/release-1.1.63/src/loader/manifest_file.cpp#L1008)
|
||||
retains filesystem manifests and then appends asset manifests. This leaves
|
||||
`/vendor`'s `XR_APILAYER_VALVE_fdm_injection` discoverable. This layer advances
|
||||
`nextInfo` exactly once, uses next-layer GIPA, preserves the rest of the
|
||||
create-info chain and never opens `vrclient.so` directly. No environment
|
||||
layer-list override or assumed ordering is needed.
|
||||
|
||||
`DISABLE_FRAME_XR_COMPAT` is the manifest's disable environment variable.
|
||||
Leave it unset to activate the implicit layer. No `enable_environment` is
|
||||
required.
|
||||
|
||||
## Rebuild and verify
|
||||
|
||||
NDK **r30 / 30.0.16248370**, installed at
|
||||
`~/Library/Android/ndk/30.0.16248370`, was the latest stable/LTS package shown
|
||||
by the [Android download page](https://developer.android.com/ndk/downloads)
|
||||
on 2026-09-28. Downloaded
|
||||
[android-ndk-r30-darwin.dmg](https://dl.google.com/android/repository/android-ndk-r30-darwin.dmg)
|
||||
(1,072,970,961 bytes). The page publishes SHA-1, not SHA-256:
|
||||
|
||||
```
|
||||
expected: 48591224b6657f46eebbc9d95d4af09bbed8d107
|
||||
actual: 48591224b6657f46eebbc9d95d4af09bbed8d107 (PASS)
|
||||
```
|
||||
|
||||
Mounted read-only with `hdiutil`; copied
|
||||
`AndroidNDK16248370.app/Contents/NDK` into that version directory. Despite the
|
||||
`darwin-x86_64` toolchain directory name, clang is universal arm64/x86_64 and
|
||||
ran on this Apple Silicon Mac.
|
||||
|
||||
```sh
|
||||
frame/openxr-compat/build.sh
|
||||
# Or set ANDROID_NDK_HOME to an installed NDK.
|
||||
cmake -S frame/openxr-compat -B frame/openxr-compat/build-host -G Ninja
|
||||
cmake --build frame/openxr-compat/build-host
|
||||
ctest --test-dir frame/openxr-compat/build-host --output-on-failure
|
||||
```
|
||||
|
||||
The script produces arm64-v8a / android-24, C++17, `-O2`, static libc++, hidden
|
||||
internal symbols, stripped output, and `-Wl,-z,max-page-size=16384`.
|
||||
The committed prebuilt is `prebuilt/arm64-v8a/libXrApiLayer_FRAME_compat.so`.
|
||||
Its SHA-256 is recorded below with the APK checks.
|
||||
|
||||
[Host test output](evidence/ctest.txt): two tests passed, covering pure logic
|
||||
and the actual layer with a fake next layer and host-only log/JNI shims.
|
||||
[Full llvm-readelf -d -s -l output](evidence/readelf.txt) records three LOAD
|
||||
segments aligned `0x4000`, only `xrNegotiateLoaderApiLayerInterface` exported,
|
||||
and only `libc.so`, `libm.so`, `libdl.so`, `liblog.so` as NEEDED libraries.
|
||||
All 46 undefined imports are versioned `@LIBC` except `__android_log_print`.
|
||||
There is no `libc++_shared.so` dependency and no unstripped `.symtab`.
|
||||
|
||||
No independent model review was run: the task explicitly prohibits delegation.
|
||||
No `CODING_STANDARDS.md` exists in this worktree or the primary worktree.
|
||||
|
||||
## Wolvic injection artifact (Mac only)
|
||||
|
||||
Copied `/tmp/vrapk/wq-dec` to `/tmp/vrapk/wq-layer-dec`; retained its existing
|
||||
LAUNCHER fix and native-library extraction setting. Added only:
|
||||
|
||||
```
|
||||
assets/openxr/1/api_layers/implicit.d/XrApiLayer_FRAME_compat.json
|
||||
lib/arm64-v8a/libXrApiLayer_FRAME_compat.so
|
||||
```
|
||||
|
||||
Built using `/tmp/vrapk/jdk/Contents/Home/bin/java` and
|
||||
`/tmp/vrapk/apktool_3.0.3.jar`, then signed in place using
|
||||
`/tmp/vrapk/uber-apk-signer-1.3.0.jar --overwrite` (embedded debug certificate):
|
||||
|
||||
```sh
|
||||
/tmp/vrapk/jdk/Contents/Home/bin/java -jar /tmp/vrapk/apktool_3.0.3.jar \
|
||||
b /tmp/vrapk/wq-layer-dec -o /tmp/vrapk/wolvic-quest-compat.apk
|
||||
/tmp/vrapk/jdk/Contents/Home/bin/java -jar /tmp/vrapk/uber-apk-signer-1.3.0.jar \
|
||||
-a /tmp/vrapk/wolvic-quest-compat.apk --overwrite
|
||||
/tmp/vrapk/jdk/Contents/Home/bin/java -jar /tmp/vrapk/uber-apk-signer-1.3.0.jar \
|
||||
-a /tmp/vrapk/wolvic-quest-compat.apk --onlyVerify
|
||||
```
|
||||
|
||||
Final APK: `/tmp/vrapk/wolvic-quest-compat.apk` (not committed).
|
||||
The bundled `lib/arm64-v8a/libopenxr_loader.so` is byte-for-byte unchanged.
|
||||
Its strings include both `openxr/1/api_layers/implicit.d/` and
|
||||
`openxr/1/api_layers/explicit.d/`, `AddManifestFilesAndroid` error messages,
|
||||
and `xrLocateSpaces`. Thus it contains APK asset discovery and evidence of
|
||||
1.1 command support. Its exact upstream release number was not established
|
||||
from the binary; runtime execution of those paths remains unverified.
|
||||
|
||||
Prebuilt library SHA-256:
|
||||
|
||||
```
|
||||
57abbcec6fbc6df7c79e2b9a46db1a5d8613b4db3c0d7e49bf87cb3172280d10
|
||||
```
|
||||
|
||||
APK SHA-256:
|
||||
|
||||
```
|
||||
355a681625e38b71563dcffecb031799eff27894d6ab910a659bace057e82c1f
|
||||
```
|
||||
|
||||
Final `--onlyVerify` exited 0: zip alignment verified, v2/v3 signatures
|
||||
verified, one APK processed and zero errors. ZIP readback confirmed that the
|
||||
injected library and manifest match the committed inputs, the loader is
|
||||
unchanged, and the binary Android manifest retains the LAUNCHER category.
|
||||
See [APK verification evidence](evidence/apk-verification.txt).
|
||||
@@ -0,0 +1,21 @@
|
||||
{
|
||||
"file_format_version": "1.0.0",
|
||||
"api_layer": {
|
||||
"name": "XR_APILAYER_FRAME_compat",
|
||||
"library_path": "libXrApiLayer_FRAME_compat.so",
|
||||
"api_version": "1.1",
|
||||
"implementation_version": "1",
|
||||
"description": "Steam Frame OpenXR 1.1 to 1.0 compatibility",
|
||||
"disable_environment": "DISABLE_FRAME_XR_COMPAT",
|
||||
"instance_extensions": [
|
||||
{
|
||||
"name": "XR_KHR_android_thread_settings",
|
||||
"extension_version": "6"
|
||||
},
|
||||
{
|
||||
"name": "XR_OCULUS_android_session_state_enable",
|
||||
"extension_version": "1"
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
Executable
+12
@@ -0,0 +1,12 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
here=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
|
||||
ndk=${ANDROID_NDK_HOME:-"$HOME/Library/Android/ndk/30.0.16248370"}
|
||||
cmake -S "$here" -B "$here/build-android" -G Ninja \
|
||||
-DCMAKE_TOOLCHAIN_FILE="$ndk/build/cmake/android.toolchain.cmake" \
|
||||
-DANDROID_ABI=arm64-v8a -DANDROID_PLATFORM=android-24 \
|
||||
-DANDROID_STL=c++_static -DCMAKE_BUILD_TYPE=Release
|
||||
cmake --build "$here/build-android"
|
||||
mkdir -p "$here/prebuilt/arm64-v8a"
|
||||
cp "$here/build-android/libXrApiLayer_FRAME_compat.so" "$here/prebuilt/arm64-v8a/"
|
||||
shasum -a 256 "$here/prebuilt/arm64-v8a/libXrApiLayer_FRAME_compat.so"
|
||||
@@ -0,0 +1,87 @@
|
||||
#pragma once
|
||||
#include <openxr/openxr.h>
|
||||
#include <algorithm>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
namespace frame {
|
||||
using Names = std::vector<std::string>;
|
||||
inline constexpr const char* layerName = "XR_APILAYER_FRAME_compat";
|
||||
inline constexpr const char* stubs[] = {"XR_KHR_android_thread_settings", "XR_OCULUS_android_session_state_enable"};
|
||||
// OpenXR-Docs release-1.1.63 registry: promotedto="XR_VERSION_1_1".
|
||||
inline constexpr const char* promotions[] = {
|
||||
"XR_KHR_locate_spaces", "XR_EXT_local_floor", "XR_EXT_uuid", "XR_EXT_palm_pose",
|
||||
"XR_VARJO_quad_views", "XR_EXT_samsung_odyssey_controller", "XR_EXT_hp_mixed_reality_controller",
|
||||
"XR_HTC_vive_cosmos_controller_interaction", "XR_HTC_vive_focus3_controller_interaction",
|
||||
"XR_ML_ml2_controller_interaction", "XR_FB_touch_controller_pro", "XR_META_touch_controller_plus",
|
||||
"XR_BD_controller_interaction", "XR_KHR_maintenance1"};
|
||||
inline bool has(const Names& names, const std::string& n) {
|
||||
return std::find(names.begin(), names.end(), n) != names.end();
|
||||
}
|
||||
inline bool downgrade(XrVersion v) { return v >= XR_MAKE_VERSION(1, 1, 0); }
|
||||
inline XrVersion runtimeVersion(XrVersion v) { return downgrade(v) ? XR_API_VERSION_1_0 : v; }
|
||||
struct ExtensionPlan { Names downstream, stubbed, missing, added; };
|
||||
inline ExtensionPlan extensions(const Names& requested, const Names& available, bool promote) {
|
||||
ExtensionPlan p;
|
||||
for (const auto& n : requested) {
|
||||
if (!has(available, n) && (n == stubs[0] || n == stubs[1])) p.stubbed.push_back(n);
|
||||
else {
|
||||
if (!has(p.downstream, n)) p.downstream.push_back(n);
|
||||
if (!has(available, n)) p.missing.push_back(n);
|
||||
}
|
||||
}
|
||||
if (promote) for (auto n : promotions) if (has(available, n) && !has(p.downstream, n)) {
|
||||
p.downstream.push_back(n); p.added.push_back(n);
|
||||
}
|
||||
return p;
|
||||
}
|
||||
inline std::string rewritePath(std::string p, bool palm) {
|
||||
const std::string suffix = "/input/grip_surface/pose";
|
||||
if (palm && (p == "/user/hand/left" + suffix || p == "/user/hand/right" + suffix))
|
||||
p.replace(p.size() - suffix.size(), suffix.size(), "/input/palm_ext/pose");
|
||||
return p;
|
||||
}
|
||||
// Profiles added to 1.1. The three legacy Meta splits have no 1.0 extension.
|
||||
// The renamed Pro/Plus profiles have different component semantics; do not
|
||||
// claim the old extension implements the new profile merely because it exists.
|
||||
inline bool dropProfile(const std::string& p, const Names& enabled) {
|
||||
for (auto name : {"touch_pro_controller", "touch_plus_controller", "touch_controller_rift_cv1",
|
||||
"touch_controller_quest_1_rift_s", "touch_controller_quest_2"})
|
||||
if (p == std::string("/interaction_profiles/meta/") + name) return true;
|
||||
const char* profiles[][2] = {
|
||||
{"samsung/odyssey_controller", "XR_EXT_samsung_odyssey_controller"},
|
||||
{"hp/mixed_reality_controller", "XR_EXT_hp_mixed_reality_controller"},
|
||||
{"htc/vive_cosmos_controller", "XR_HTC_vive_cosmos_controller_interaction"},
|
||||
{"htc/vive_focus3_controller", "XR_HTC_vive_focus3_controller_interaction"},
|
||||
{"ml/ml2_controller", "XR_ML_ml2_controller_interaction"},
|
||||
{"bytedance/pico_neo3_controller", "XR_BD_controller_interaction"},
|
||||
{"bytedance/pico4_controller", "XR_BD_controller_interaction"},
|
||||
{"bytedance/pico_g3_controller", "XR_BD_controller_interaction"}};
|
||||
for (auto& entry : profiles) if (p == std::string("/interaction_profiles/") + entry[0])
|
||||
return !has(enabled, entry[1]);
|
||||
return false;
|
||||
}
|
||||
inline XrStructureType extensionType(XrStructureType t) {
|
||||
switch (t) {
|
||||
case XR_TYPE_SPACES_LOCATE_INFO: return XR_TYPE_SPACES_LOCATE_INFO_KHR;
|
||||
case XR_TYPE_SPACE_LOCATIONS: return XR_TYPE_SPACE_LOCATIONS_KHR;
|
||||
case XR_TYPE_SPACE_VELOCITIES: return XR_TYPE_SPACE_VELOCITIES_KHR;
|
||||
default: return t;
|
||||
}
|
||||
}
|
||||
inline XrResult locate(PFN_xrLocateSpacesKHR next, XrSession session,
|
||||
const XrSpacesLocateInfo* info, XrSpaceLocations* locations) {
|
||||
if (!info || !locations) return XR_ERROR_VALIDATION_FAILURE;
|
||||
static_assert(XR_TYPE_SPACE_VELOCITIES == XR_TYPE_SPACE_VELOCITIES_KHR);
|
||||
static_assert(XR_TYPE_SPACE_LOCATIONS == XR_TYPE_SPACE_LOCATIONS_KHR);
|
||||
static_assert(XR_TYPE_SPACES_LOCATE_INFO == XR_TYPE_SPACES_LOCATE_INFO_KHR);
|
||||
auto in = *info;
|
||||
auto out = *locations;
|
||||
in.type = extensionType(in.type); out.type = extensionType(out.type);
|
||||
// The enums and typedefs are exact aliases. All chained velocities,
|
||||
// including unknown next structures, can be forwarded without mutation.
|
||||
const auto result = next(session, &in, &out);
|
||||
locations->locationCount = out.locationCount;
|
||||
return result;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,29 @@
|
||||
2026-09-28, Mac only; no device connection.
|
||||
APK: /tmp/vrapk/wolvic-quest-compat.apk
|
||||
SHA-256: 355a681625e38b71563dcffecb031799eff27894d6ab910a659bace057e82c1f
|
||||
|
||||
Command:
|
||||
/tmp/vrapk/jdk/Contents/Home/bin/java -jar /tmp/vrapk/uber-apk-signer-1.3.0.jar -a /tmp/vrapk/wolvic-quest-compat.apk --onlyVerify
|
||||
Exit status: 0
|
||||
Relevant output:
|
||||
- zipalign verified
|
||||
- signature verified [v2, v3]
|
||||
Successfully processed 1 APKs and 0 errors in 0.63 seconds.
|
||||
|
||||
ZIP readback checks: PASS
|
||||
- Injected JSON identical to frame/openxr-compat/XrApiLayer_FRAME_compat.json.
|
||||
- Injected SO identical to prebuilt/arm64-v8a/libXrApiLayer_FRAME_compat.so.
|
||||
- Existing libopenxr_loader.so identical to /tmp/vrapk/wq-dec version.
|
||||
- Binary AndroidManifest.xml contains android.intent.category.LAUNCHER.
|
||||
|
||||
Loader strings present:
|
||||
openxr/1/api_layers/implicit.d/
|
||||
openxr/1/api_layers/explicit.d/
|
||||
ApiLayerManifestFile::AddManifestFilesAndroid unable to open asset
|
||||
xrLocateSpaces
|
||||
|
||||
NDK: 30.0.16248370 (r30)
|
||||
DMG size: 1072970961 bytes
|
||||
Download-page SHA-1: 48591224b6657f46eebbc9d95d4af09bbed8d107
|
||||
Measured SHA-1: 48591224b6657f46eebbc9d95d4af09bbed8d107
|
||||
SHA check: PASS
|
||||
@@ -0,0 +1,9 @@
|
||||
Test project /Users/saphid/projects/steam-frame-xrlayer/frame/openxr-compat/build-host
|
||||
Start 1: compat_logic
|
||||
1/2 Test #1: compat_logic ..................... Passed 0.01 sec
|
||||
Start 2: layer_dispatch
|
||||
2/2 Test #2: layer_dispatch ................... Passed 0.42 sec
|
||||
|
||||
100% tests passed out of 2
|
||||
|
||||
Total Test time (real) = 0.43 sec
|
||||
@@ -0,0 +1,110 @@
|
||||
|
||||
Elf file type is DYN (Shared object file)
|
||||
Entry point 0x0
|
||||
There are 9 program headers, starting at offset 64
|
||||
|
||||
Program Headers:
|
||||
Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align
|
||||
PHDR 0x000040 0x0000000000000040 0x0000000000000040 0x0001f8 0x0001f8 R 0x8
|
||||
LOAD 0x000000 0x0000000000000000 0x0000000000000000 0x0169e0 0x0169e0 R E 0x4000
|
||||
LOAD 0x0169e0 0x000000000001a9e0 0x000000000001a9e0 0x000a90 0x001620 RW 0x4000
|
||||
LOAD 0x017470 0x000000000001f470 0x000000000001f470 0x000068 0x000bc0 RW 0x4000
|
||||
DYNAMIC 0x017048 0x000000000001b048 0x000000000001b048 0x0001c0 0x0001c0 RW 0x8
|
||||
GNU_RELRO 0x0169e0 0x000000000001a9e0 0x000000000001a9e0 0x000a90 0x001620 R 0x1
|
||||
GNU_EH_FRAME 0x004fb4 0x0000000000004fb4 0x0000000000004fb4 0x00070c 0x00070c R 0x4
|
||||
GNU_STACK 0x000000 0x0000000000000000 0x0000000000000000 0x000000 0x000000 RW 0x0
|
||||
NOTE 0x000238 0x0000000000000238 0x0000000000000238 0x0000bc 0x0000bc R 0x4
|
||||
|
||||
Section to Segment mapping:
|
||||
Segment Sections...
|
||||
00
|
||||
01 .note.android.ident .note.gnu.build-id .dynsym .gnu.version .gnu.version_r .gnu.hash .dynstr .rela.dyn .rela.plt .gcc_except_table .rodata .eh_frame_hdr .eh_frame .text __lcxx_override .plt
|
||||
02 .data.rel.ro .fini_array .init_array .dynamic .got .got.plt .relro_padding
|
||||
03 .data .bss
|
||||
04 .dynamic
|
||||
05 .data.rel.ro .fini_array .init_array .dynamic .got .got.plt .relro_padding
|
||||
06 .eh_frame_hdr
|
||||
07
|
||||
08 .note.android.ident .note.gnu.build-id
|
||||
None .comment .shstrtab
|
||||
Dynamic section at offset 0x17048 contains 28 entries:
|
||||
Tag Type Name/Value
|
||||
0x0000000000000001 (NEEDED) Shared library: [liblog.so]
|
||||
0x0000000000000001 (NEEDED) Shared library: [libm.so]
|
||||
0x0000000000000001 (NEEDED) Shared library: [libdl.so]
|
||||
0x0000000000000001 (NEEDED) Shared library: [libc.so]
|
||||
0x000000000000000e (SONAME) Library soname: [libXrApiLayer_FRAME_compat.so]
|
||||
0x000000000000001e (FLAGS) BIND_NOW
|
||||
0x000000006ffffffb (FLAGS_1) NOW
|
||||
0x0000000000000007 (RELA) 0xae8
|
||||
0x0000000000000008 (RELASZ) 5424 (bytes)
|
||||
0x0000000000000009 (RELAENT) 24 (bytes)
|
||||
0x000000006ffffff9 (RELACOUNT) 225
|
||||
0x0000000000000017 (JMPREL) 0x2018
|
||||
0x0000000000000002 (PLTRELSZ) 1080 (bytes)
|
||||
0x0000000000000003 (PLTGOT) 0x1b2f0
|
||||
0x0000000000000014 (PLTREL) RELA
|
||||
0x0000000000000006 (SYMTAB) 0x2f8
|
||||
0x000000000000000b (SYMENT) 24 (bytes)
|
||||
0x0000000000000005 (STRTAB) 0x838
|
||||
0x000000000000000a (STRSZ) 681 (bytes)
|
||||
0x000000006ffffef5 (GNU_HASH) 0x818
|
||||
0x0000000000000019 (INIT_ARRAY) 0x1b030
|
||||
0x000000000000001b (INIT_ARRAYSZ) 24 (bytes)
|
||||
0x000000000000001a (FINI_ARRAY) 0x1b020
|
||||
0x000000000000001c (FINI_ARRAYSZ) 16 (bytes)
|
||||
0x000000006ffffff0 (VERSYM) 0x778
|
||||
0x000000006ffffffe (VERNEED) 0x7d8
|
||||
0x000000006fffffff (VERNEEDNUM) 2
|
||||
0x0000000000000000 (NULL) 0x0
|
||||
|
||||
Symbol table '.dynsym' contains 48 entries:
|
||||
Num: Value Size Type Bind Vis Ndx Name
|
||||
0: 0000000000000000 0 NOTYPE LOCAL DEFAULT UND
|
||||
1: 0000000000000000 0 FUNC GLOBAL DEFAULT UND __cxa_finalize@LIBC
|
||||
2: 0000000000000000 0 FUNC GLOBAL DEFAULT UND __cxa_atexit@LIBC
|
||||
3: 0000000000000000 0 FUNC GLOBAL DEFAULT UND strcmp@LIBC
|
||||
4: 0000000000000000 0 FUNC GLOBAL DEFAULT UND __android_log_print
|
||||
5: 0000000000000000 0 FUNC GLOBAL DEFAULT UND __stack_chk_fail@LIBC
|
||||
6: 0000000000000000 0 FUNC GLOBAL DEFAULT UND memmove@LIBC
|
||||
7: 0000000000000000 0 FUNC GLOBAL DEFAULT UND strlen@LIBC
|
||||
8: 0000000000000000 0 FUNC GLOBAL DEFAULT UND memcpy@LIBC
|
||||
9: 0000000000000000 0 FUNC GLOBAL DEFAULT UND __strcpy_chk@LIBC
|
||||
10: 0000000000000000 0 FUNC GLOBAL DEFAULT UND memset@LIBC
|
||||
11: 0000000000000000 0 FUNC GLOBAL DEFAULT UND memcmp@LIBC
|
||||
12: 0000000000000000 0 FUNC GLOBAL DEFAULT UND pthread_mutex_lock@LIBC
|
||||
13: 0000000000000000 0 FUNC GLOBAL DEFAULT UND pthread_mutex_unlock@LIBC
|
||||
14: 0000000000000000 0 FUNC GLOBAL DEFAULT UND __errno@LIBC
|
||||
15: 0000000000000000 0 FUNC GLOBAL DEFAULT UND snprintf@LIBC
|
||||
16: 0000000000000000 0 FUNC GLOBAL DEFAULT UND pthread_mutex_destroy@LIBC
|
||||
17: 0000000000000000 0 FUNC GLOBAL DEFAULT UND strerror_r@LIBC
|
||||
18: 0000000000000000 0 FUNC GLOBAL DEFAULT UND abort@LIBC
|
||||
19: 0000000000000000 0 FUNC GLOBAL DEFAULT UND pthread_getspecific@LIBC
|
||||
20: 0000000000000000 0 FUNC GLOBAL DEFAULT UND pthread_setspecific@LIBC
|
||||
21: 0000000000000000 0 FUNC GLOBAL DEFAULT UND pthread_key_create@LIBC
|
||||
22: 0000000000000000 0 FUNC GLOBAL DEFAULT UND syscall@LIBC
|
||||
23: 0000000000000000 0 OBJECT GLOBAL DEFAULT UND __sF@LIBC
|
||||
24: 0000000000000000 0 FUNC GLOBAL DEFAULT UND fwrite@LIBC
|
||||
25: 0000000000000000 0 FUNC GLOBAL DEFAULT UND vfprintf@LIBC
|
||||
26: 0000000000000000 0 FUNC GLOBAL DEFAULT UND fputc@LIBC
|
||||
27: 0000000000000000 0 FUNC GLOBAL DEFAULT UND vasprintf@LIBC
|
||||
28: 0000000000000000 0 FUNC GLOBAL DEFAULT UND android_set_abort_message@LIBC
|
||||
29: 0000000000000000 0 FUNC GLOBAL DEFAULT UND openlog@LIBC
|
||||
30: 0000000000000000 0 FUNC GLOBAL DEFAULT UND syslog@LIBC
|
||||
31: 0000000000000000 0 FUNC GLOBAL DEFAULT UND closelog@LIBC
|
||||
32: 0000000000000000 0 FUNC GLOBAL DEFAULT UND malloc@LIBC
|
||||
33: 0000000000000000 0 FUNC GLOBAL DEFAULT UND free@LIBC
|
||||
34: 0000000000000000 0 FUNC GLOBAL DEFAULT UND posix_memalign@LIBC
|
||||
35: 0000000000000000 0 FUNC GLOBAL DEFAULT UND realloc@LIBC
|
||||
36: 0000000000000000 0 FUNC GLOBAL DEFAULT UND pthread_once@LIBC
|
||||
37: 0000000000000000 0 FUNC GLOBAL DEFAULT UND pthread_key_delete@LIBC
|
||||
38: 0000000000000000 0 FUNC GLOBAL DEFAULT UND getauxval@LIBC
|
||||
39: 0000000000000000 0 FUNC GLOBAL DEFAULT UND __system_property_get@LIBC
|
||||
40: 0000000000000000 0 FUNC GLOBAL DEFAULT UND strncmp@LIBC
|
||||
41: 0000000000000000 0 FUNC GLOBAL DEFAULT UND fprintf@LIBC
|
||||
42: 0000000000000000 0 FUNC GLOBAL DEFAULT UND fflush@LIBC
|
||||
43: 0000000000000000 0 FUNC GLOBAL DEFAULT UND pthread_rwlock_wrlock@LIBC
|
||||
44: 0000000000000000 0 FUNC GLOBAL DEFAULT UND pthread_rwlock_unlock@LIBC
|
||||
45: 0000000000000000 0 FUNC GLOBAL DEFAULT UND dl_iterate_phdr@LIBC
|
||||
46: 0000000000000000 0 FUNC GLOBAL DEFAULT UND pthread_rwlock_rdlock@LIBC
|
||||
47: 00000000000081a0 284 FUNC GLOBAL DEFAULT 14 xrNegotiateLoaderApiLayerInterface
|
||||
@@ -0,0 +1,272 @@
|
||||
#include "compat_logic.h"
|
||||
#include <loader_interfaces.h>
|
||||
#include <jni.h>
|
||||
#include <openxr/openxr_platform.h>
|
||||
#include <android/log.h>
|
||||
#include <cstring>
|
||||
#include <memory>
|
||||
#include <mutex>
|
||||
#include <unordered_map>
|
||||
|
||||
#define LOG(...) __android_log_print(ANDROID_LOG_INFO, "FrameXrCompat", __VA_ARGS__)
|
||||
#define GUARD_END catch (const std::bad_alloc&) { return XR_ERROR_OUT_OF_MEMORY; } catch (...) { return XR_ERROR_RUNTIME_FAILURE; }
|
||||
namespace {
|
||||
struct Dispatch {
|
||||
PFN_xrGetInstanceProcAddr gipa{};
|
||||
PFN_xrDestroyInstance destroy{};
|
||||
PFN_xrCreateSession createSession{};
|
||||
PFN_xrDestroySession destroySession{};
|
||||
PFN_xrLocateSpacesKHR locate{};
|
||||
PFN_xrStringToPath stringToPath{};
|
||||
PFN_xrPathToString pathToString{};
|
||||
PFN_xrSuggestInteractionProfileBindings suggest{};
|
||||
PFN_xrSetAndroidApplicationThreadKHR thread{};
|
||||
frame::Names enabled, stubbed;
|
||||
XrInstance instance{};
|
||||
bool promote{}, palm{};
|
||||
};
|
||||
std::mutex mutex;
|
||||
std::unordered_map<XrInstance, std::shared_ptr<Dispatch>> instances;
|
||||
std::unordered_map<XrSession, std::shared_ptr<Dispatch>> sessions;
|
||||
// No runtime library is opened here: every call goes through the next layer.
|
||||
PFN_xrEnumerateInstanceExtensionProperties enumerateNext{};
|
||||
template<class T> T proc(PFN_xrGetInstanceProcAddr gipa, XrInstance i, const char* name) {
|
||||
PFN_xrVoidFunction f{};
|
||||
if (XR_FAILED(gipa(i, name, &f))) return nullptr;
|
||||
return reinterpret_cast<T>(f);
|
||||
}
|
||||
std::shared_ptr<Dispatch> get(XrInstance i) {
|
||||
std::lock_guard<std::mutex> lock(mutex);
|
||||
auto it = instances.find(i); return it == instances.end() ? nullptr : it->second;
|
||||
}
|
||||
std::shared_ptr<Dispatch> get(XrSession s) {
|
||||
std::lock_guard<std::mutex> lock(mutex);
|
||||
auto it = sessions.find(s); return it == sessions.end() ? nullptr : it->second;
|
||||
}
|
||||
XrResult properties(PFN_xrEnumerateInstanceExtensionProperties fn,
|
||||
std::vector<XrExtensionProperties>& out) {
|
||||
if (!fn) return XR_ERROR_FUNCTION_UNSUPPORTED;
|
||||
for (int attempt = 0; attempt < 4; ++attempt) {
|
||||
uint32_t n{};
|
||||
auto r = fn(nullptr, 0, &n, nullptr);
|
||||
if (XR_FAILED(r)) return r;
|
||||
out.assign(n, {XR_TYPE_EXTENSION_PROPERTIES, nullptr, {}, 0});
|
||||
if (!n) return XR_SUCCESS;
|
||||
r = fn(nullptr, n, &n, out.data());
|
||||
if (r == XR_ERROR_SIZE_INSUFFICIENT) continue;
|
||||
if (XR_FAILED(r)) return r;
|
||||
out.resize(n); return XR_SUCCESS;
|
||||
}
|
||||
return XR_ERROR_RUNTIME_FAILURE;
|
||||
}
|
||||
XrResult XRAPI_CALL enumerate(const char* layer, uint32_t capacity, uint32_t* count,
|
||||
XrExtensionProperties* output) try {
|
||||
if (!count || (capacity && !output)) return XR_ERROR_VALIDATION_FAILURE;
|
||||
const bool own = layer && std::strcmp(layer, frame::layerName) == 0;
|
||||
PFN_xrEnumerateInstanceExtensionProperties next;
|
||||
{ std::lock_guard<std::mutex> lock(mutex); next = enumerateNext; }
|
||||
if (layer && *layer && !own) return next ? next(layer, capacity, count, output) : XR_ERROR_API_LAYER_NOT_PRESENT;
|
||||
std::vector<XrExtensionProperties> all;
|
||||
if (!own && next) {
|
||||
auto r = properties(next, all); if (XR_FAILED(r)) return r;
|
||||
}
|
||||
for (unsigned i = 0; i < 2; ++i) {
|
||||
bool found = false;
|
||||
for (auto& e : all) if (!std::strcmp(e.extensionName, frame::stubs[i])) found = true;
|
||||
if (!found) {
|
||||
XrExtensionProperties p{XR_TYPE_EXTENSION_PROPERTIES, nullptr, {}, i == 0 ? XR_KHR_android_thread_settings_SPEC_VERSION : 1u};
|
||||
std::strcpy(p.extensionName, frame::stubs[i]); all.push_back(p);
|
||||
}
|
||||
}
|
||||
*count = static_cast<uint32_t>(all.size());
|
||||
LOG("enumerate extensions: %u (includes stubs)", *count);
|
||||
if (!capacity) return XR_SUCCESS;
|
||||
if (capacity < all.size()) return XR_ERROR_SIZE_INSUFFICIENT;
|
||||
for (size_t i = 0; i < all.size(); ++i) {
|
||||
if (output[i].type != XR_TYPE_EXTENSION_PROPERTIES) return XR_ERROR_VALIDATION_FAILURE;
|
||||
std::strcpy(output[i].extensionName, all[i].extensionName);
|
||||
output[i].extensionVersion = all[i].extensionVersion;
|
||||
}
|
||||
return XR_SUCCESS;
|
||||
} GUARD_END
|
||||
XrResult XRAPI_CALL destroyInstance(XrInstance i) try {
|
||||
auto d = get(i); if (!d) return XR_ERROR_HANDLE_INVALID;
|
||||
auto r = d->destroy(i);
|
||||
if (XR_SUCCEEDED(r)) {
|
||||
std::lock_guard<std::mutex> lock(mutex);
|
||||
for (auto it = sessions.begin(); it != sessions.end();) {
|
||||
if (it->second == d) it = sessions.erase(it); else ++it;
|
||||
}
|
||||
instances.erase(i);
|
||||
if (instances.empty()) enumerateNext = nullptr;
|
||||
}
|
||||
return r;
|
||||
} GUARD_END
|
||||
XrResult XRAPI_CALL createSession(XrInstance i, const XrSessionCreateInfo* info, XrSession* s) try {
|
||||
auto d = get(i); if (!d) return XR_ERROR_HANDLE_INVALID;
|
||||
auto r = d->createSession(i, info, s);
|
||||
if (XR_SUCCEEDED(r)) {
|
||||
try { std::lock_guard<std::mutex> lock(mutex); sessions.emplace(*s, d); }
|
||||
catch (...) { d->destroySession(*s); *s = XR_NULL_HANDLE; throw; }
|
||||
}
|
||||
return r;
|
||||
} GUARD_END
|
||||
XrResult XRAPI_CALL destroySession(XrSession s) try {
|
||||
auto d = get(s); if (!d) return XR_ERROR_HANDLE_INVALID;
|
||||
auto r = d->destroySession(s);
|
||||
if (XR_SUCCEEDED(r)) { std::lock_guard<std::mutex> lock(mutex); sessions.erase(s); }
|
||||
return r;
|
||||
} GUARD_END
|
||||
XrResult XRAPI_CALL locateSpaces(XrSession s, const XrSpacesLocateInfo* in, XrSpaceLocations* out) try {
|
||||
auto d = get(s); if (!d) return XR_ERROR_HANDLE_INVALID;
|
||||
if (!d->locate) return XR_ERROR_FUNCTION_UNSUPPORTED;
|
||||
LOG("xrLocateSpaces -> xrLocateSpacesKHR (core/KHR type aliases)");
|
||||
return frame::locate(d->locate, s, in, out);
|
||||
} GUARD_END
|
||||
XrResult XRAPI_CALL threadSettings(XrSession s, XrAndroidThreadTypeKHR type, uint32_t tid) try {
|
||||
auto d = get(s); if (!d) return XR_ERROR_HANDLE_INVALID;
|
||||
if (frame::has(d->stubbed, frame::stubs[0])) {
|
||||
LOG("stub xrSetAndroidApplicationThreadKHR type=%d tid=%u -> XR_SUCCESS (no scheduling change)", type, tid);
|
||||
return XR_SUCCESS;
|
||||
}
|
||||
return d->thread ? d->thread(s, type, tid) : XR_ERROR_FUNCTION_UNSUPPORTED;
|
||||
} GUARD_END
|
||||
XrResult XRAPI_CALL stringToPath(XrInstance i, const char* path, XrPath* out) try {
|
||||
auto d = get(i); if (!d) return XR_ERROR_HANDLE_INVALID;
|
||||
if (!path) return XR_ERROR_VALIDATION_FAILURE;
|
||||
auto rewritten = frame::rewritePath(path, d->palm);
|
||||
if (rewritten != path) LOG("path %s -> %s", path, rewritten.c_str());
|
||||
return d->stringToPath(i, rewritten.c_str(), out);
|
||||
} GUARD_END
|
||||
XrResult pathString(const Dispatch& d, XrPath path, std::string& out) {
|
||||
uint32_t n{};
|
||||
auto r = d.pathToString(d.instance, path, 0, &n, nullptr);
|
||||
if (XR_FAILED(r)) return r;
|
||||
std::vector<char> text(n);
|
||||
r = d.pathToString(d.instance, path, n, &n, text.data());
|
||||
if (XR_SUCCEEDED(r)) out.assign(text.data());
|
||||
return r;
|
||||
}
|
||||
XrResult XRAPI_CALL suggest(XrInstance i, const XrInteractionProfileSuggestedBinding* info) try {
|
||||
auto d = get(i); if (!d) return XR_ERROR_HANDLE_INVALID;
|
||||
if (!info || (info->countSuggestedBindings && !info->suggestedBindings)) return XR_ERROR_VALIDATION_FAILURE;
|
||||
std::string profile;
|
||||
auto r = pathString(*d, info->interactionProfile, profile);
|
||||
if (XR_FAILED(r)) return r;
|
||||
if (d->promote && frame::dropProfile(profile, d->enabled)) {
|
||||
LOG("drop unsupported 1.1 interaction profile %s (%u suggestions)", profile.c_str(), info->countSuggestedBindings);
|
||||
return XR_SUCCESS;
|
||||
}
|
||||
auto copy = *info;
|
||||
std::vector<XrActionSuggestedBinding> bindings;
|
||||
for (uint32_t index = 0; index < info->countSuggestedBindings; ++index) {
|
||||
auto b = info->suggestedBindings[index];
|
||||
std::string path;
|
||||
r = pathString(*d, b.binding, path); if (XR_FAILED(r)) return r;
|
||||
auto rewritten = frame::rewritePath(path, d->palm);
|
||||
if (rewritten != path) {
|
||||
LOG("binding %s -> %s", path.c_str(), rewritten.c_str());
|
||||
r = d->stringToPath(i, rewritten.c_str(), &b.binding); if (XR_FAILED(r)) return r;
|
||||
}
|
||||
bindings.push_back(b);
|
||||
}
|
||||
copy.suggestedBindings = bindings.data();
|
||||
return d->suggest(i, ©);
|
||||
} GUARD_END
|
||||
XrResult XRAPI_CALL gipa(XrInstance, const char*, PFN_xrVoidFunction*);
|
||||
XrResult XRAPI_CALL createLayer(const XrInstanceCreateInfo* info, const XrApiLayerCreateInfo* layer,
|
||||
XrInstance* instance) try {
|
||||
if (!info || !instance || !layer || layer->structType != XR_LOADER_INTERFACE_STRUCT_API_LAYER_CREATE_INFO ||
|
||||
layer->structVersion != XR_API_LAYER_CREATE_INFO_STRUCT_VERSION || layer->structSize != sizeof(*layer) ||
|
||||
!layer->nextInfo || layer->nextInfo->structType != XR_LOADER_INTERFACE_STRUCT_API_LAYER_NEXT_INFO ||
|
||||
layer->nextInfo->structVersion != XR_API_LAYER_NEXT_INFO_STRUCT_VERSION ||
|
||||
layer->nextInfo->structSize != sizeof(XrApiLayerNextInfo) ||
|
||||
!layer->nextInfo->nextGetInstanceProcAddr || !layer->nextInfo->nextCreateApiLayerInstance ||
|
||||
(info->enabledExtensionCount && !info->enabledExtensionNames)) return XR_ERROR_INITIALIZATION_FAILED;
|
||||
*instance = XR_NULL_HANDLE;
|
||||
auto next = layer->nextInfo->nextGetInstanceProcAddr;
|
||||
auto enumFn = proc<PFN_xrEnumerateInstanceExtensionProperties>(next, XR_NULL_HANDLE, "xrEnumerateInstanceExtensionProperties");
|
||||
std::vector<XrExtensionProperties> available;
|
||||
auto r = properties(enumFn, available); if (XR_FAILED(r)) { LOG("runtime extension enumeration failed: %d", r); return r; }
|
||||
frame::Names requested, supported;
|
||||
for (auto& p : available) supported.emplace_back(p.extensionName);
|
||||
for (uint32_t n = 0; n < info->enabledExtensionCount; ++n) {
|
||||
if (!info->enabledExtensionNames[n]) return XR_ERROR_VALIDATION_FAILURE;
|
||||
requested.emplace_back(info->enabledExtensionNames[n]);
|
||||
}
|
||||
auto d = std::make_shared<Dispatch>();
|
||||
d->promote = frame::downgrade(info->applicationInfo.apiVersion);
|
||||
auto plan = frame::extensions(requested, supported, d->promote);
|
||||
for (auto& n : plan.added) LOG("enable promoted extension %s", n.c_str());
|
||||
for (auto& n : plan.stubbed) LOG("emulate missing extension %s; remove downstream", n.c_str());
|
||||
for (auto& n : plan.missing) LOG("unsupported extension %s retained; runtime must reject", n.c_str());
|
||||
auto copy = *info;
|
||||
copy.applicationInfo.apiVersion = frame::runtimeVersion(info->applicationInfo.apiVersion);
|
||||
if (d->promote) LOG("API %u.%u.%u -> 1.0.%u", unsigned(XR_VERSION_MAJOR(info->applicationInfo.apiVersion)),
|
||||
unsigned(XR_VERSION_MINOR(info->applicationInfo.apiVersion)), unsigned(XR_VERSION_PATCH(info->applicationInfo.apiVersion)),
|
||||
unsigned(XR_VERSION_PATCH(copy.applicationInfo.apiVersion)));
|
||||
std::vector<const char*> names;
|
||||
for (auto& n : plan.downstream) names.push_back(n.c_str());
|
||||
copy.enabledExtensionCount = static_cast<uint32_t>(names.size()); copy.enabledExtensionNames = names.data();
|
||||
auto chain = *layer; chain.nextInfo = layer->nextInfo->next;
|
||||
r = layer->nextInfo->nextCreateApiLayerInstance(©, &chain, instance);
|
||||
if (XR_FAILED(r)) { LOG("downstream xrCreateInstance -> %d", r); return r; }
|
||||
d->gipa = next; d->instance = *instance;
|
||||
d->destroy = proc<PFN_xrDestroyInstance>(next, *instance, "xrDestroyInstance");
|
||||
// A successful runtime instance must expose xrDestroyInstance.
|
||||
if (!d->destroy) { LOG("invalid downstream: missing xrDestroyInstance"); return XR_ERROR_INITIALIZATION_FAILED; }
|
||||
try {
|
||||
d->enabled = std::move(plan.downstream); d->stubbed = std::move(plan.stubbed);
|
||||
d->palm = frame::has(d->enabled, "XR_EXT_palm_pose");
|
||||
#define LOAD(field, name) d->field = proc<PFN_##name>(next, *instance, #name)
|
||||
LOAD(createSession, xrCreateSession); LOAD(destroySession, xrDestroySession);
|
||||
LOAD(stringToPath, xrStringToPath); LOAD(pathToString, xrPathToString);
|
||||
LOAD(suggest, xrSuggestInteractionProfileBindings);
|
||||
if (frame::has(d->enabled, "XR_KHR_locate_spaces")) LOAD(locate, xrLocateSpacesKHR);
|
||||
if (frame::has(d->enabled, frame::stubs[0])) LOAD(thread, xrSetAndroidApplicationThreadKHR);
|
||||
#undef LOAD
|
||||
if (!d->createSession || !d->destroySession || !d->stringToPath || !d->pathToString || !d->suggest) {
|
||||
d->destroy(*instance); *instance = XR_NULL_HANDLE; return XR_ERROR_INITIALIZATION_FAILED;
|
||||
}
|
||||
std::lock_guard<std::mutex> lock(mutex);
|
||||
instances.emplace(*instance, d); enumerateNext = enumFn;
|
||||
} catch (...) { d->destroy(*instance); *instance = XR_NULL_HANDLE; throw; }
|
||||
LOG("created instance; next-layer dispatch retained (Valve layer coexists)");
|
||||
return r;
|
||||
} GUARD_END
|
||||
XrResult XRAPI_CALL gipa(XrInstance i, const char* name, PFN_xrVoidFunction* out) try {
|
||||
if (!name || !out) return XR_ERROR_VALIDATION_FAILURE;
|
||||
*out = nullptr;
|
||||
#define RETURN_PROC(n, fn) if (!std::strcmp(name, n)) { *out = reinterpret_cast<PFN_xrVoidFunction>(fn); return XR_SUCCESS; }
|
||||
RETURN_PROC("xrGetInstanceProcAddr", gipa)
|
||||
RETURN_PROC("xrCreateApiLayerInstance", createLayer)
|
||||
RETURN_PROC("xrEnumerateInstanceExtensionProperties", enumerate)
|
||||
auto d = get(i); if (!d) return XR_ERROR_HANDLE_INVALID;
|
||||
RETURN_PROC("xrDestroyInstance", destroyInstance)
|
||||
RETURN_PROC("xrCreateSession", createSession)
|
||||
RETURN_PROC("xrDestroySession", destroySession)
|
||||
RETURN_PROC("xrStringToPath", stringToPath)
|
||||
RETURN_PROC("xrSuggestInteractionProfileBindings", suggest)
|
||||
if (d->locate && d->promote) { RETURN_PROC("xrLocateSpaces", locateSpaces) }
|
||||
if (frame::has(d->stubbed, frame::stubs[0])) { RETURN_PROC("xrSetAndroidApplicationThreadKHR", threadSettings) }
|
||||
#undef RETURN_PROC
|
||||
// Includes xrGetInstanceProperties: report the actual runtime's identity.
|
||||
return d->gipa(i, name, out);
|
||||
} GUARD_END
|
||||
} // namespace
|
||||
extern "C" __attribute__((visibility("default"))) XrResult XRAPI_CALL xrNegotiateLoaderApiLayerInterface(
|
||||
const XrNegotiateLoaderInfo* loader, const char* name, XrNegotiateApiLayerRequest* request) {
|
||||
if (!loader || !name || !request || std::strcmp(name, frame::layerName) ||
|
||||
loader->structType != XR_LOADER_INTERFACE_STRUCT_LOADER_INFO ||
|
||||
loader->structVersion != XR_LOADER_INFO_STRUCT_VERSION || loader->structSize != sizeof(*loader) ||
|
||||
request->structType != XR_LOADER_INTERFACE_STRUCT_API_LAYER_REQUEST ||
|
||||
request->structVersion != XR_API_LAYER_INFO_STRUCT_VERSION || request->structSize != sizeof(*request) ||
|
||||
loader->minInterfaceVersion > 1 || loader->maxInterfaceVersion < 1 ||
|
||||
loader->minApiVersion > XR_CURRENT_API_VERSION || loader->maxApiVersion < XR_MAKE_VERSION(1, 1, 0))
|
||||
return XR_ERROR_INITIALIZATION_FAILED;
|
||||
request->layerInterfaceVersion = 1;
|
||||
request->layerApiVersion = std::min<XrVersion>(XR_CURRENT_API_VERSION, loader->maxApiVersion);
|
||||
request->getInstanceProcAddr = gipa; request->createApiLayerInstance = createLayer;
|
||||
LOG("negotiated interface 1, API 1.1");
|
||||
return XR_SUCCESS;
|
||||
}
|
||||
Binary file not shown.
@@ -0,0 +1,70 @@
|
||||
#include "compat_logic.h"
|
||||
#include <cstdlib>
|
||||
#include <iostream>
|
||||
#include <type_traits>
|
||||
#define CHECK(expr) do { if (!(expr)) { std::cerr << __LINE__ << ": " #expr "\n"; std::exit(1); } } while (false)
|
||||
namespace {
|
||||
void* sentinel = reinterpret_cast<void*>(0x1234);
|
||||
XrResult XRAPI_CALL fakeLocate(XrSession, const XrSpacesLocateInfo* in, XrSpaceLocations* out) {
|
||||
CHECK(in->type == XR_TYPE_SPACES_LOCATE_INFO_KHR);
|
||||
CHECK(out->type == XR_TYPE_SPACE_LOCATIONS_KHR);
|
||||
CHECK(in->next == sentinel);
|
||||
auto* velocities = static_cast<XrSpaceVelocitiesKHR*>(out->next);
|
||||
CHECK(velocities->type == XR_TYPE_SPACE_VELOCITIES_KHR);
|
||||
CHECK(velocities->next == sentinel);
|
||||
CHECK(in->spaceCount == 1 && in->time == 123);
|
||||
out->locations[0].pose.position.x = 42;
|
||||
velocities->velocities[0].linearVelocity.y = 7;
|
||||
return XR_SUCCESS;
|
||||
}
|
||||
}
|
||||
int main() {
|
||||
using namespace frame;
|
||||
CHECK(!downgrade(XR_MAKE_VERSION(1, 0, 99)));
|
||||
CHECK(runtimeVersion(XR_MAKE_VERSION(1, 0, 42)) == XR_MAKE_VERSION(1, 0, 42));
|
||||
CHECK(runtimeVersion(XR_MAKE_VERSION(1, 1, 0)) == XR_API_VERSION_1_0);
|
||||
CHECK(runtimeVersion(XR_MAKE_VERSION(1, 1, 999)) == XR_API_VERSION_1_0);
|
||||
CHECK(runtimeVersion(XR_MAKE_VERSION(2, 0, 0)) == XR_API_VERSION_1_0);
|
||||
Names available{"XR_KHR_locate_spaces", "XR_EXT_palm_pose", "XR_EXT_hand_interaction", "XR_VARJO_quad_views"};
|
||||
Names requested{stubs[0], stubs[1], "XR_MISSING_test", "XR_EXT_palm_pose"};
|
||||
auto p = extensions(requested, available, true);
|
||||
CHECK(p.stubbed.size() == 2 && p.missing == Names{"XR_MISSING_test"});
|
||||
CHECK(has(p.downstream, "XR_MISSING_test"));
|
||||
CHECK(has(p.downstream, "XR_KHR_locate_spaces") && has(p.downstream, "XR_VARJO_quad_views"));
|
||||
CHECK(!has(p.downstream, "XR_EXT_hand_interaction"));
|
||||
CHECK(!has(p.downstream, "XR_EXT_local_floor"));
|
||||
CHECK(std::count(p.downstream.begin(), p.downstream.end(), "XR_EXT_palm_pose") == 1);
|
||||
available.push_back(stubs[0]);
|
||||
CHECK(extensions(requested, available, true).stubbed == Names{stubs[1]});
|
||||
CHECK(extensions({}, available, false).downstream.empty());
|
||||
CHECK(rewritePath("/user/hand/left/input/grip_surface/pose", true) == "/user/hand/left/input/palm_ext/pose");
|
||||
CHECK(rewritePath("/user/hand/right/input/grip_surface/pose", true) == "/user/hand/right/input/palm_ext/pose");
|
||||
CHECK(rewritePath("/user/hand/left/input/grip_surface/pose", false) == "/user/hand/left/input/grip_surface/pose");
|
||||
CHECK(rewritePath("/user/hand/left/input/grip_surface/pose/extra", true) == "/user/hand/left/input/grip_surface/pose/extra");
|
||||
CHECK(rewritePath("/user/hand/left/input/grip/pose", true) == "/user/hand/left/input/grip/pose");
|
||||
CHECK(dropProfile("/interaction_profiles/meta/touch_pro_controller", {}));
|
||||
CHECK(dropProfile("/interaction_profiles/meta/touch_controller_quest_2", {}));
|
||||
CHECK(dropProfile("/interaction_profiles/hp/mixed_reality_controller", {}));
|
||||
CHECK(!dropProfile("/interaction_profiles/hp/mixed_reality_controller", {"XR_EXT_hp_mixed_reality_controller"}));
|
||||
CHECK(!dropProfile("/interaction_profiles/oculus/touch_controller", {}));
|
||||
CHECK(!dropProfile("/interaction_profiles/khr/simple_controller", {}));
|
||||
CHECK(!dropProfile("/interaction_profiles/valve/frame_controller", {}));
|
||||
CHECK(!dropProfile("/interaction_profiles/ext/hand_interaction_ext", {}));
|
||||
CHECK(extensionType(XR_TYPE_SPACES_LOCATE_INFO) == XR_TYPE_SPACES_LOCATE_INFO_KHR);
|
||||
CHECK(extensionType(XR_TYPE_SPACE_LOCATIONS) == XR_TYPE_SPACE_LOCATIONS_KHR);
|
||||
CHECK(extensionType(XR_TYPE_SPACE_VELOCITIES) == XR_TYPE_SPACE_VELOCITIES_KHR);
|
||||
CHECK(extensionType(XR_TYPE_INSTANCE_CREATE_INFO) == XR_TYPE_INSTANCE_CREATE_INFO);
|
||||
static_assert(std::is_same_v<XrSpaceVelocities, XrSpaceVelocitiesKHR>);
|
||||
XrSpace space{};
|
||||
XrSpaceLocationData data{};
|
||||
XrSpaceVelocityData velocity{};
|
||||
XrSpaceVelocities velocities{XR_TYPE_SPACE_VELOCITIES, sentinel, 1, &velocity};
|
||||
XrSpaceLocations locations{XR_TYPE_SPACE_LOCATIONS, &velocities, 1, &data};
|
||||
XrSpacesLocateInfo info{XR_TYPE_SPACES_LOCATE_INFO, sentinel, XR_NULL_HANDLE, 123, 1, &space};
|
||||
CHECK(locate(fakeLocate, XR_NULL_HANDLE, &info, &locations) == XR_SUCCESS);
|
||||
CHECK(data.pose.position.x == 42 && velocity.linearVelocity.y == 7);
|
||||
CHECK(info.next == sentinel && locations.next == &velocities && velocities.next == sentinel);
|
||||
CHECK(info.type == XR_TYPE_SPACES_LOCATE_INFO && locations.type == XR_TYPE_SPACE_LOCATIONS && velocities.type == XR_TYPE_SPACE_VELOCITIES);
|
||||
CHECK(locate(fakeLocate, XR_NULL_HANDLE, nullptr, &locations) == XR_ERROR_VALIDATION_FAILURE);
|
||||
std::cout << "All version, extension, path/profile and locate-chain checks passed\n";
|
||||
}
|
||||
@@ -0,0 +1,134 @@
|
||||
// Compile the actual layer with host-only JNI/logging shims, and a fake next
|
||||
// layer. This exercises ABI routing without a runtime or a headset.
|
||||
#include "../layer.cpp"
|
||||
#include <cstdlib>
|
||||
#include <iostream>
|
||||
#define CHECK(expr) do { if (!(expr)) { std::cerr << __LINE__ << ": " #expr "\n"; std::exit(1); } } while (false)
|
||||
namespace {
|
||||
uintptr_t serial = 100;
|
||||
frame::Names seenExtensions;
|
||||
XrVersion seenVersion{};
|
||||
XrApiLayerNextInfo* seenNext{};
|
||||
int suggestionCalls{}, locateCalls{}, realThreadCalls{};
|
||||
bool nativeThread{};
|
||||
std::unordered_map<XrPath, std::string> paths;
|
||||
XrResult XRAPI_CALL fakeEnumerate(const char*, uint32_t capacity, uint32_t* count, XrExtensionProperties* out) {
|
||||
const char* extensions[] = {"XR_KHR_locate_spaces", "XR_EXT_palm_pose", frame::stubs[0]};
|
||||
*count = nativeThread ? 3 : 2;
|
||||
if (!capacity) return XR_SUCCESS;
|
||||
if (capacity < *count) return XR_ERROR_SIZE_INSUFFICIENT;
|
||||
for (uint32_t j = 0; j < *count; ++j) { std::strcpy(out[j].extensionName, extensions[j]); out[j].extensionVersion = 1; }
|
||||
return XR_SUCCESS;
|
||||
}
|
||||
XrResult XRAPI_CALL fakeCreate(const XrInstanceCreateInfo* in, const XrApiLayerCreateInfo* layer, XrInstance* i) {
|
||||
seenVersion = in->applicationInfo.apiVersion; seenNext = layer->nextInfo;
|
||||
seenExtensions.clear();
|
||||
for (uint32_t j = 0; j < in->enabledExtensionCount; ++j) seenExtensions.emplace_back(in->enabledExtensionNames[j]);
|
||||
if (frame::has(seenExtensions, "XR_MISSING_test")) return XR_ERROR_EXTENSION_NOT_PRESENT;
|
||||
*i = reinterpret_cast<XrInstance>(++serial); return XR_SUCCESS;
|
||||
}
|
||||
XrResult XRAPI_CALL fakeDestroy(XrInstance) { return XR_SUCCESS; }
|
||||
XrResult XRAPI_CALL fakeCreateSession(XrInstance, const XrSessionCreateInfo*, XrSession* s) {
|
||||
*s = reinterpret_cast<XrSession>(++serial); return XR_SUCCESS;
|
||||
}
|
||||
XrResult XRAPI_CALL fakeDestroySession(XrSession) { return XR_SUCCESS; }
|
||||
XrResult XRAPI_CALL fakeString(XrInstance, const char* text, XrPath* p) {
|
||||
*p = ++serial; paths[*p] = text; return XR_SUCCESS;
|
||||
}
|
||||
XrResult XRAPI_CALL fakePath(XrInstance, XrPath p, uint32_t cap, uint32_t* count, char* out) {
|
||||
if (!paths.count(p)) return XR_ERROR_PATH_INVALID;
|
||||
*count = static_cast<uint32_t>(paths[p].size() + 1);
|
||||
if (!cap) return XR_SUCCESS;
|
||||
if (cap < *count) return XR_ERROR_SIZE_INSUFFICIENT;
|
||||
std::strcpy(out, paths[p].c_str()); return XR_SUCCESS;
|
||||
}
|
||||
XrResult XRAPI_CALL fakeSuggest(XrInstance, const XrInteractionProfileSuggestedBinding* info) {
|
||||
++suggestionCalls;
|
||||
if (info->countSuggestedBindings) CHECK(paths[info->suggestedBindings[0].binding] == "/user/hand/left/input/palm_ext/pose");
|
||||
return XR_SUCCESS;
|
||||
}
|
||||
XrResult XRAPI_CALL fakeLocate(XrSession, const XrSpacesLocateInfo*, XrSpaceLocations*) { ++locateCalls; return XR_SUCCESS; }
|
||||
XrResult XRAPI_CALL fakeThread(XrSession, XrAndroidThreadTypeKHR, uint32_t) { ++realThreadCalls; return XR_TIMEOUT_EXPIRED; }
|
||||
XrResult XRAPI_CALL fakeProperties(XrInstance, XrInstanceProperties*) { return XR_SUCCESS; }
|
||||
XrResult XRAPI_CALL fakeGipa(XrInstance, const char* n, PFN_xrVoidFunction* out) {
|
||||
#define MAP(name, f) if (!std::strcmp(n, name)) { *out = reinterpret_cast<PFN_xrVoidFunction>(f); return XR_SUCCESS; }
|
||||
MAP("xrEnumerateInstanceExtensionProperties", fakeEnumerate)
|
||||
MAP("xrDestroyInstance", fakeDestroy)
|
||||
MAP("xrCreateSession", fakeCreateSession) MAP("xrDestroySession", fakeDestroySession)
|
||||
MAP("xrStringToPath", fakeString) MAP("xrPathToString", fakePath)
|
||||
MAP("xrSuggestInteractionProfileBindings", fakeSuggest) MAP("xrLocateSpacesKHR", fakeLocate)
|
||||
MAP("xrSetAndroidApplicationThreadKHR", fakeThread) MAP("xrGetInstanceProperties", fakeProperties)
|
||||
#undef MAP
|
||||
*out = nullptr; return XR_ERROR_FUNCTION_UNSUPPORTED;
|
||||
}
|
||||
}
|
||||
int main() {
|
||||
XrNegotiateLoaderInfo loader{XR_LOADER_INTERFACE_STRUCT_LOADER_INFO, 1, sizeof(XrNegotiateLoaderInfo), 1, 1,
|
||||
XR_MAKE_VERSION(1,0,0), XR_MAKE_VERSION(1,1023,4095)};
|
||||
XrNegotiateApiLayerRequest request{};
|
||||
request.structType = XR_LOADER_INTERFACE_STRUCT_API_LAYER_REQUEST; request.structVersion = 1; request.structSize = sizeof(request);
|
||||
CHECK(xrNegotiateLoaderApiLayerInterface(&loader, frame::layerName, &request) == XR_SUCCESS);
|
||||
CHECK(request.getInstanceProcAddr && request.createApiLayerInstance);
|
||||
loader.maxApiVersion = XR_MAKE_VERSION(1,1,0);
|
||||
CHECK(xrNegotiateLoaderApiLayerInterface(&loader, frame::layerName, &request) == XR_SUCCESS);
|
||||
CHECK(request.layerApiVersion == loader.maxApiVersion);
|
||||
loader.maxApiVersion = XR_MAKE_VERSION(1,0,99);
|
||||
CHECK(xrNegotiateLoaderApiLayerInterface(&loader, frame::layerName, &request) == XR_ERROR_INITIALIZATION_FAILED);
|
||||
loader.maxApiVersion = XR_MAKE_VERSION(1,1023,4095);
|
||||
CHECK(xrNegotiateLoaderApiLayerInterface(&loader, "wrong", &request) == XR_ERROR_INITIALIZATION_FAILED);
|
||||
XrApiLayerNextInfo tail{};
|
||||
XrApiLayerNextInfo next{XR_LOADER_INTERFACE_STRUCT_API_LAYER_NEXT_INFO, 1, sizeof(XrApiLayerNextInfo), {}, fakeGipa, fakeCreate, &tail};
|
||||
XrApiLayerCreateInfo layer{XR_LOADER_INTERFACE_STRUCT_API_LAYER_CREATE_INFO, 1, sizeof(XrApiLayerCreateInfo), nullptr, {}, &next};
|
||||
XrInstanceCreateInfo info{XR_TYPE_INSTANCE_CREATE_INFO, nullptr, 0, {}, 0, nullptr, 2, frame::stubs};
|
||||
info.applicationInfo.apiVersion = XR_MAKE_VERSION(1,1,999);
|
||||
XrInstance a{}, b{};
|
||||
CHECK(createLayer(&info, &layer, &a) == XR_SUCCESS);
|
||||
CHECK(seenVersion == XR_API_VERSION_1_0 && info.applicationInfo.apiVersion == XR_MAKE_VERSION(1,1,999));
|
||||
CHECK(seenNext == &tail && layer.nextInfo == &next);
|
||||
CHECK(!frame::has(seenExtensions, frame::stubs[0]) && frame::has(seenExtensions, "XR_KHR_locate_spaces"));
|
||||
XrSession sa{}, sb{};
|
||||
CHECK(createSession(a, nullptr, &sa) == XR_SUCCESS);
|
||||
CHECK(threadSettings(sa, XR_ANDROID_THREAD_TYPE_APPLICATION_MAIN_KHR, 1) == XR_SUCCESS);
|
||||
nativeThread = true;
|
||||
CHECK(createLayer(&info, &layer, &b) == XR_SUCCESS);
|
||||
CHECK(frame::has(seenExtensions, frame::stubs[0]));
|
||||
CHECK(createSession(b, nullptr, &sb) == XR_SUCCESS);
|
||||
PFN_xrVoidFunction fn{};
|
||||
CHECK(gipa(b, "xrSetAndroidApplicationThreadKHR", &fn) == XR_SUCCESS);
|
||||
CHECK(reinterpret_cast<PFN_xrSetAndroidApplicationThreadKHR>(fn)(sb, XR_ANDROID_THREAD_TYPE_APPLICATION_MAIN_KHR, 1) == XR_TIMEOUT_EXPIRED);
|
||||
CHECK(realThreadCalls == 1);
|
||||
CHECK(threadSettings(sa, XR_ANDROID_THREAD_TYPE_APPLICATION_MAIN_KHR, 1) == XR_SUCCESS);
|
||||
CHECK(gipa(a, "xrGetInstanceProperties", &fn) == XR_SUCCESS && fn == reinterpret_cast<PFN_xrVoidFunction>(fakeProperties));
|
||||
CHECK(gipa(a, "xrLocateSpaces", &fn) == XR_SUCCESS);
|
||||
XrSpacesLocateInfo locateInfo{XR_TYPE_SPACES_LOCATE_INFO, nullptr, XR_NULL_HANDLE, 1, 0, nullptr};
|
||||
XrSpaceLocations locations{XR_TYPE_SPACE_LOCATIONS, nullptr, 0, nullptr};
|
||||
CHECK(reinterpret_cast<PFN_xrLocateSpaces>(fn)(sa, &locateInfo, &locations) == XR_SUCCESS && locateCalls == 1);
|
||||
XrPath binding{}, profile{};
|
||||
CHECK(stringToPath(a, "/user/hand/left/input/grip_surface/pose", &binding) == XR_SUCCESS);
|
||||
CHECK(paths[binding] == "/user/hand/left/input/palm_ext/pose");
|
||||
fakeString(a, "/user/hand/left/input/grip_surface/pose", &binding); // preexisting path: rewrite in suggest too
|
||||
fakeString(a, "/interaction_profiles/oculus/touch_controller", &profile);
|
||||
XrActionSuggestedBinding action{XR_NULL_HANDLE, binding};
|
||||
XrInteractionProfileSuggestedBinding suggested{XR_TYPE_INTERACTION_PROFILE_SUGGESTED_BINDING, nullptr, profile, 1, &action};
|
||||
CHECK(suggest(a, &suggested) == XR_SUCCESS && suggestionCalls == 1);
|
||||
CHECK(paths[action.binding] == "/user/hand/left/input/grip_surface/pose");
|
||||
fakeString(a, "/interaction_profiles/meta/touch_pro_controller", &suggested.interactionProfile);
|
||||
CHECK(suggest(a, &suggested) == XR_SUCCESS && suggestionCalls == 1);
|
||||
uint32_t count{};
|
||||
CHECK(enumerate(frame::layerName, 0, &count, nullptr) == XR_SUCCESS && count == 2);
|
||||
XrExtensionProperties props[2]{{XR_TYPE_EXTENSION_PROPERTIES, nullptr, {}, 0}, {XR_TYPE_EXTENSION_PROPERTIES, nullptr, {}, 0}};
|
||||
CHECK(enumerate(frame::layerName, 1, &count, props) == XR_ERROR_SIZE_INSUFFICIENT);
|
||||
CHECK(enumerate(frame::layerName, 2, &count, props) == XR_SUCCESS && count == 2);
|
||||
CHECK(enumerate(nullptr, 0, &count, nullptr) == XR_SUCCESS && count == 4);
|
||||
const char* missing = "XR_MISSING_test";
|
||||
info.enabledExtensionCount = 1; info.enabledExtensionNames = &missing;
|
||||
XrInstance failed{};
|
||||
CHECK(createLayer(&info, &layer, &failed) == XR_ERROR_EXTENSION_NOT_PRESENT && failed == XR_NULL_HANDLE);
|
||||
CHECK(destroySession(sa) == XR_SUCCESS);
|
||||
CHECK(threadSettings(sa, XR_ANDROID_THREAD_TYPE_APPLICATION_MAIN_KHR, 1) == XR_ERROR_HANDLE_INVALID);
|
||||
CHECK(destroyInstance(a) == XR_SUCCESS);
|
||||
CHECK(get(sb) && !get(a));
|
||||
CHECK(destroyInstance(b) == XR_SUCCESS && !get(sb));
|
||||
CHECK(instances.empty() && sessions.empty() && enumerateNext == nullptr);
|
||||
std::cout << "Negotiation, next-layer chaining, multi-instance dispatch, stubs, forwarding and cleanup passed\n";
|
||||
}
|
||||
@@ -0,0 +1,9 @@
|
||||
#pragma once
|
||||
// Host-only logcat replacement. Android builds use the NDK header and liblog.
|
||||
#include <cstdarg>
|
||||
#include <cstdio>
|
||||
#define ANDROID_LOG_INFO 4
|
||||
inline int __android_log_print(int, const char*, const char* fmt, ...) {
|
||||
va_list args; va_start(args, fmt); auto r = std::vfprintf(stderr, fmt, args);
|
||||
va_end(args); std::fputc('\n', stderr); return r;
|
||||
}
|
||||
@@ -0,0 +1,3 @@
|
||||
#pragma once
|
||||
// Only the opaque jobject declaration is needed by openxr_platform.h.
|
||||
typedef void* jobject;
|
||||
Vendored
+208
@@ -0,0 +1,208 @@
|
||||
Apache License
|
||||
|
||||
Version 2.0, January 2004
|
||||
|
||||
http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION,
|
||||
AND DISTRIBUTION
|
||||
|
||||
1. Definitions.
|
||||
|
||||
|
||||
|
||||
"License" shall mean the terms and conditions for use, reproduction, and distribution
|
||||
as defined by Sections 1 through 9 of this document.
|
||||
|
||||
|
||||
|
||||
"Licensor" shall mean the copyright owner or entity authorized by the copyright
|
||||
owner that is granting the License.
|
||||
|
||||
|
||||
|
||||
"Legal Entity" shall mean the union of the acting entity and all other entities
|
||||
that control, are controlled by, or are under common control with that entity.
|
||||
For the purposes of this definition, "control" means (i) the power, direct
|
||||
or indirect, to cause the direction or management of such entity, whether
|
||||
by contract or otherwise, or (ii) ownership of fifty percent (50%) or more
|
||||
of the outstanding shares, or (iii) beneficial ownership of such entity.
|
||||
|
||||
|
||||
|
||||
"You" (or "Your") shall mean an individual or Legal Entity exercising permissions
|
||||
granted by this License.
|
||||
|
||||
|
||||
|
||||
"Source" form shall mean the preferred form for making modifications, including
|
||||
but not limited to software source code, documentation source, and configuration
|
||||
files.
|
||||
|
||||
|
||||
|
||||
"Object" form shall mean any form resulting from mechanical transformation
|
||||
or translation of a Source form, including but not limited to compiled object
|
||||
code, generated documentation, and conversions to other media types.
|
||||
|
||||
|
||||
|
||||
"Work" shall mean the work of authorship, whether in Source or Object form,
|
||||
made available under the License, as indicated by a copyright notice that
|
||||
is included in or attached to the work (an example is provided in the Appendix
|
||||
below).
|
||||
|
||||
|
||||
|
||||
"Derivative Works" shall mean any work, whether in Source or Object form,
|
||||
that is based on (or derived from) the Work and for which the editorial revisions,
|
||||
annotations, elaborations, or other modifications represent, as a whole, an
|
||||
original work of authorship. For the purposes of this License, Derivative
|
||||
Works shall not include works that remain separable from, or merely link (or
|
||||
bind by name) to the interfaces of, the Work and Derivative Works thereof.
|
||||
|
||||
|
||||
|
||||
"Contribution" shall mean any work of authorship, including the original version
|
||||
of the Work and any modifications or additions to that Work or Derivative
|
||||
Works thereof, that is intentionally submitted to Licensor for inclusion in
|
||||
the Work by the copyright owner or by an individual or Legal Entity authorized
|
||||
to submit on behalf of the copyright owner. For the purposes of this definition,
|
||||
"submitted" means any form of electronic, verbal, or written communication
|
||||
sent to the Licensor or its representatives, including but not limited to
|
||||
communication on electronic mailing lists, source code control systems, and
|
||||
issue tracking systems that are managed by, or on behalf of, the Licensor
|
||||
for the purpose of discussing and improving the Work, but excluding communication
|
||||
that is conspicuously marked or otherwise designated in writing by the copyright
|
||||
owner as "Not a Contribution."
|
||||
|
||||
|
||||
|
||||
"Contributor" shall mean Licensor and any individual or Legal Entity on behalf
|
||||
of whom a Contribution has been received by Licensor and subsequently incorporated
|
||||
within the Work.
|
||||
|
||||
2. Grant of Copyright License. Subject to the terms and conditions of this
|
||||
License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive,
|
||||
no-charge, royalty-free, irrevocable copyright license to reproduce, prepare
|
||||
Derivative Works of, publicly display, publicly perform, sublicense, and distribute
|
||||
the Work and such Derivative Works in Source or Object form.
|
||||
|
||||
3. Grant of Patent License. Subject to the terms and conditions of this License,
|
||||
each Contributor hereby grants to You a perpetual, worldwide, non-exclusive,
|
||||
no-charge, royalty-free, irrevocable (except as stated in this section) patent
|
||||
license to make, have made, use, offer to sell, sell, import, and otherwise
|
||||
transfer the Work, where such license applies only to those patent claims
|
||||
licensable by such Contributor that are necessarily infringed by their Contribution(s)
|
||||
alone or by combination of their Contribution(s) with the Work to which such
|
||||
Contribution(s) was submitted. If You institute patent litigation against
|
||||
any entity (including a cross-claim or counterclaim in a lawsuit) alleging
|
||||
that the Work or a Contribution incorporated within the Work constitutes direct
|
||||
or contributory patent infringement, then any patent licenses granted to You
|
||||
under this License for that Work shall terminate as of the date such litigation
|
||||
is filed.
|
||||
|
||||
4. Redistribution. You may reproduce and distribute copies of the Work or
|
||||
Derivative Works thereof in any medium, with or without modifications, and
|
||||
in Source or Object form, provided that You meet the following conditions:
|
||||
|
||||
(a) You must give any other recipients of the Work or Derivative Works a copy
|
||||
of this License; and
|
||||
|
||||
(b) You must cause any modified files to carry prominent notices stating that
|
||||
You changed the files; and
|
||||
|
||||
(c) You must retain, in the Source form of any Derivative Works that You distribute,
|
||||
all copyright, patent, trademark, and attribution notices from the Source
|
||||
form of the Work, excluding those notices that do not pertain to any part
|
||||
of the Derivative Works; and
|
||||
|
||||
(d) If the Work includes a "NOTICE" text file as part of its distribution,
|
||||
then any Derivative Works that You distribute must include a readable copy
|
||||
of the attribution notices contained within such NOTICE file, excluding those
|
||||
notices that do not pertain to any part of the Derivative Works, in at least
|
||||
one of the following places: within a NOTICE text file distributed as part
|
||||
of the Derivative Works; within the Source form or documentation, if provided
|
||||
along with the Derivative Works; or, within a display generated by the Derivative
|
||||
Works, if and wherever such third-party notices normally appear. The contents
|
||||
of the NOTICE file are for informational purposes only and do not modify the
|
||||
License. You may add Your own attribution notices within Derivative Works
|
||||
that You distribute, alongside or as an addendum to the NOTICE text from the
|
||||
Work, provided that such additional attribution notices cannot be construed
|
||||
as modifying the License.
|
||||
|
||||
You may add Your own copyright statement to Your modifications and may provide
|
||||
additional or different license terms and conditions for use, reproduction,
|
||||
or distribution of Your modifications, or for any such Derivative Works as
|
||||
a whole, provided Your use, reproduction, and distribution of the Work otherwise
|
||||
complies with the conditions stated in this License.
|
||||
|
||||
5. Submission of Contributions. Unless You explicitly state otherwise, any
|
||||
Contribution intentionally submitted for inclusion in the Work by You to the
|
||||
Licensor shall be under the terms and conditions of this License, without
|
||||
any additional terms or conditions. Notwithstanding the above, nothing herein
|
||||
shall supersede or modify the terms of any separate license agreement you
|
||||
may have executed with Licensor regarding such Contributions.
|
||||
|
||||
6. Trademarks. This License does not grant permission to use the trade names,
|
||||
trademarks, service marks, or product names of the Licensor, except as required
|
||||
for reasonable and customary use in describing the origin of the Work and
|
||||
reproducing the content of the NOTICE file.
|
||||
|
||||
7. Disclaimer of Warranty. Unless required by applicable law or agreed to
|
||||
in writing, Licensor provides the Work (and each Contributor provides its
|
||||
Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
||||
KIND, either express or implied, including, without limitation, any warranties
|
||||
or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR
|
||||
A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness
|
||||
of using or redistributing the Work and assume any risks associated with Your
|
||||
exercise of permissions under this License.
|
||||
|
||||
8. Limitation of Liability. In no event and under no legal theory, whether
|
||||
in tort (including negligence), contract, or otherwise, unless required by
|
||||
applicable law (such as deliberate and grossly negligent acts) or agreed to
|
||||
in writing, shall any Contributor be liable to You for damages, including
|
||||
any direct, indirect, special, incidental, or consequential damages of any
|
||||
character arising as a result of this License or out of the use or inability
|
||||
to use the Work (including but not limited to damages for loss of goodwill,
|
||||
work stoppage, computer failure or malfunction, or any and all other commercial
|
||||
damages or losses), even if such Contributor has been advised of the possibility
|
||||
of such damages.
|
||||
|
||||
9. Accepting Warranty or Additional Liability. While redistributing the Work
|
||||
or Derivative Works thereof, You may choose to offer, and charge a fee for,
|
||||
acceptance of support, warranty, indemnity, or other liability obligations
|
||||
and/or rights consistent with this License. However, in accepting such obligations,
|
||||
You may act only on Your own behalf and on Your sole responsibility, not on
|
||||
behalf of any other Contributor, and only if You agree to indemnify, defend,
|
||||
and hold each Contributor harmless for any liability incurred by, or claims
|
||||
asserted against, such Contributor by reason of your accepting any such warranty
|
||||
or additional liability. END OF TERMS AND CONDITIONS
|
||||
|
||||
APPENDIX: How to apply the Apache License to your work.
|
||||
|
||||
To apply the Apache License to your work, attach the following boilerplate
|
||||
notice, with the fields enclosed by brackets "[]" replaced with your own identifying
|
||||
information. (Don't include the brackets!) The text should be enclosed in
|
||||
the appropriate comment syntax for the file format. We also recommend that
|
||||
a file or class name and description of purpose be included on the same "printed
|
||||
page" as the copyright notice for easier identification within third-party
|
||||
archives.
|
||||
|
||||
Copyright [yyyy] [name of copyright owner]
|
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License");
|
||||
|
||||
you may not use this file except in compliance with the License.
|
||||
|
||||
You may obtain a copy of the License at
|
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software
|
||||
|
||||
distributed under the License is distributed on an "AS IS" BASIS,
|
||||
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
|
||||
See the License for the specific language governing permissions and
|
||||
|
||||
limitations under the License.
|
||||
+114
@@ -0,0 +1,114 @@
|
||||
// Copyright (c) 2017-2023, The Khronos Group Inc.
|
||||
// Copyright (c) 2017 Valve Corporation
|
||||
// Copyright (c) 2017 LunarG, Inc.
|
||||
//
|
||||
// SPDX-License-Identifier: Apache-2.0 OR MIT
|
||||
//
|
||||
// Initial Author: Mark Young <marky@lunarg.com>
|
||||
//
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <openxr/openxr.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
// Forward declare.
|
||||
typedef struct XrApiLayerCreateInfo XrApiLayerCreateInfo;
|
||||
|
||||
// Function pointer prototype for the xrCreateApiLayerInstance function used in place of xrCreateInstance.
|
||||
// This function allows us to pass special API layer information to each layer during the process of creating an Instance.
|
||||
typedef XrResult(XRAPI_PTR *PFN_xrCreateApiLayerInstance)(const XrInstanceCreateInfo *info,
|
||||
const XrApiLayerCreateInfo *apiLayerInfo, XrInstance *instance);
|
||||
|
||||
// Loader/API Layer Interface versions
|
||||
// 1 - First version, introduces negotiation structure and functions
|
||||
#define XR_CURRENT_LOADER_API_LAYER_VERSION 1
|
||||
|
||||
// Loader/Runtime Interface versions
|
||||
// 1 - First version, introduces negotiation structure and functions
|
||||
#define XR_CURRENT_LOADER_RUNTIME_VERSION 1
|
||||
|
||||
// Version negotiation values
|
||||
typedef enum XrLoaderInterfaceStructs {
|
||||
XR_LOADER_INTERFACE_STRUCT_UNINTIALIZED = 0,
|
||||
XR_LOADER_INTERFACE_STRUCT_LOADER_INFO,
|
||||
XR_LOADER_INTERFACE_STRUCT_API_LAYER_REQUEST,
|
||||
XR_LOADER_INTERFACE_STRUCT_RUNTIME_REQUEST,
|
||||
XR_LOADER_INTERFACE_STRUCT_API_LAYER_CREATE_INFO,
|
||||
XR_LOADER_INTERFACE_STRUCT_API_LAYER_NEXT_INFO,
|
||||
} XrLoaderInterfaceStructs;
|
||||
|
||||
#define XR_LOADER_INFO_STRUCT_VERSION 1
|
||||
typedef struct XrNegotiateLoaderInfo {
|
||||
XrLoaderInterfaceStructs structType; // XR_LOADER_INTERFACE_STRUCT_LOADER_INFO
|
||||
uint32_t structVersion; // XR_LOADER_INFO_STRUCT_VERSION
|
||||
size_t structSize; // sizeof(XrNegotiateLoaderInfo)
|
||||
uint32_t minInterfaceVersion;
|
||||
uint32_t maxInterfaceVersion;
|
||||
XrVersion minApiVersion;
|
||||
XrVersion maxApiVersion;
|
||||
} XrNegotiateLoaderInfo;
|
||||
|
||||
#define XR_API_LAYER_INFO_STRUCT_VERSION 1
|
||||
typedef struct XrNegotiateApiLayerRequest {
|
||||
XrLoaderInterfaceStructs structType; // XR_LOADER_INTERFACE_STRUCT_API_LAYER_REQUEST
|
||||
uint32_t structVersion; // XR_API_LAYER_INFO_STRUCT_VERSION
|
||||
size_t structSize; // sizeof(XrNegotiateApiLayerRequest)
|
||||
uint32_t layerInterfaceVersion; // CURRENT_LOADER_API_LAYER_VERSION
|
||||
XrVersion layerApiVersion;
|
||||
PFN_xrGetInstanceProcAddr getInstanceProcAddr;
|
||||
PFN_xrCreateApiLayerInstance createApiLayerInstance;
|
||||
} XrNegotiateApiLayerRequest;
|
||||
|
||||
#define XR_RUNTIME_INFO_STRUCT_VERSION 1
|
||||
typedef struct XrNegotiateRuntimeRequest {
|
||||
XrLoaderInterfaceStructs structType; // XR_LOADER_INTERFACE_STRUCT_RUNTIME_REQUEST
|
||||
uint32_t structVersion; // XR_RUNTIME_INFO_STRUCT_VERSION
|
||||
size_t structSize; // sizeof(XrNegotiateRuntimeRequest)
|
||||
uint32_t runtimeInterfaceVersion; // CURRENT_LOADER_RUNTIME_VERSION
|
||||
XrVersion runtimeApiVersion;
|
||||
PFN_xrGetInstanceProcAddr getInstanceProcAddr;
|
||||
} XrNegotiateRuntimeRequest;
|
||||
|
||||
// Function used to negotiate an interface betewen the loader and an API layer. Each library exposing one or
|
||||
// more API layers needs to expose at least this function.
|
||||
typedef XrResult(XRAPI_PTR *PFN_xrNegotiateLoaderApiLayerInterface)(const XrNegotiateLoaderInfo *loaderInfo,
|
||||
const char *apiLayerName,
|
||||
XrNegotiateApiLayerRequest *apiLayerRequest);
|
||||
|
||||
// Function used to negotiate an interface betewen the loader and a runtime. Each runtime should expose
|
||||
// at least this function.
|
||||
typedef XrResult(XRAPI_PTR *PFN_xrNegotiateLoaderRuntimeInterface)(const XrNegotiateLoaderInfo *loaderInfo,
|
||||
XrNegotiateRuntimeRequest *runtimeRequest);
|
||||
|
||||
// Forward declare.
|
||||
typedef struct XrApiLayerNextInfo XrApiLayerNextInfo;
|
||||
|
||||
#define XR_API_LAYER_NEXT_INFO_STRUCT_VERSION 1
|
||||
struct XrApiLayerNextInfo {
|
||||
XrLoaderInterfaceStructs structType; // XR_LOADER_INTERFACE_STRUCT_API_LAYER_NEXT_INFO
|
||||
uint32_t structVersion; // XR_API_LAYER_NEXT_INFO_STRUCT_VERSION
|
||||
size_t structSize; // sizeof(XrApiLayerNextInfo)
|
||||
char layerName[XR_MAX_API_LAYER_NAME_SIZE]; // Name of API layer which should receive this info
|
||||
PFN_xrGetInstanceProcAddr nextGetInstanceProcAddr; // Pointer to next API layer's xrGetInstanceProcAddr
|
||||
PFN_xrCreateApiLayerInstance nextCreateApiLayerInstance; // Pointer to next API layer's xrCreateApiLayerInstance
|
||||
XrApiLayerNextInfo *next; // Pointer to the next API layer info in the sequence
|
||||
};
|
||||
|
||||
#define XR_API_LAYER_MAX_SETTINGS_PATH_SIZE 512
|
||||
#define XR_API_LAYER_CREATE_INFO_STRUCT_VERSION 1
|
||||
typedef struct XrApiLayerCreateInfo {
|
||||
XrLoaderInterfaceStructs structType; // XR_LOADER_INTERFACE_STRUCT_API_LAYER_CREATE_INFO
|
||||
uint32_t structVersion; // XR_API_LAYER_CREATE_INFO_STRUCT_VERSION
|
||||
size_t structSize; // sizeof(XrApiLayerCreateInfo)
|
||||
void *loaderInstance; // Pointer to the LoaderInstance class
|
||||
char settings_file_location[XR_API_LAYER_MAX_SETTINGS_PATH_SIZE]; // Location to the found settings file (or empty '\0')
|
||||
XrApiLayerNextInfo *nextInfo; // Pointer to the next API layer's Info
|
||||
} XrApiLayerCreateInfo;
|
||||
|
||||
#ifdef __cplusplus
|
||||
} // extern "C"
|
||||
#endif
|
||||
+14911
File diff suppressed because it is too large.
Load diff
+819
@@ -0,0 +1,819 @@
|
||||
#ifndef OPENXR_PLATFORM_H_
|
||||
#define OPENXR_PLATFORM_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2017-2026 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0 OR MIT
|
||||
*/
|
||||
|
||||
/*
|
||||
** This header is generated from the Khronos OpenXR XML API Registry.
|
||||
**
|
||||
*/
|
||||
|
||||
#include "openxr.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef XR_USE_PLATFORM_ANDROID
|
||||
|
||||
// XR_KHR_android_thread_settings is a preprocessor guard. Do not pass it to API calls.
|
||||
#define XR_KHR_android_thread_settings 1
|
||||
#define XR_KHR_android_thread_settings_SPEC_VERSION 6
|
||||
#define XR_KHR_ANDROID_THREAD_SETTINGS_EXTENSION_NAME "XR_KHR_android_thread_settings"
|
||||
|
||||
typedef enum XrAndroidThreadTypeKHR {
|
||||
XR_ANDROID_THREAD_TYPE_APPLICATION_MAIN_KHR = 1,
|
||||
XR_ANDROID_THREAD_TYPE_APPLICATION_WORKER_KHR = 2,
|
||||
XR_ANDROID_THREAD_TYPE_RENDERER_MAIN_KHR = 3,
|
||||
XR_ANDROID_THREAD_TYPE_RENDERER_WORKER_KHR = 4,
|
||||
XR_ANDROID_THREAD_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF
|
||||
} XrAndroidThreadTypeKHR;
|
||||
typedef XrResult (XRAPI_PTR *PFN_xrSetAndroidApplicationThreadKHR)(XrSession session, XrAndroidThreadTypeKHR threadType, uint32_t threadId);
|
||||
|
||||
#ifndef XR_NO_PROTOTYPES
|
||||
#ifdef XR_EXTENSION_PROTOTYPES
|
||||
XRAPI_ATTR XrResult XRAPI_CALL xrSetAndroidApplicationThreadKHR(
|
||||
XrSession session,
|
||||
XrAndroidThreadTypeKHR threadType,
|
||||
uint32_t threadId);
|
||||
#endif /* XR_EXTENSION_PROTOTYPES */
|
||||
#endif /* !XR_NO_PROTOTYPES */
|
||||
#endif /* XR_USE_PLATFORM_ANDROID */
|
||||
|
||||
#ifdef XR_USE_PLATFORM_ANDROID
|
||||
|
||||
// XR_KHR_android_surface_swapchain is a preprocessor guard. Do not pass it to API calls.
|
||||
#define XR_KHR_android_surface_swapchain 1
|
||||
#define XR_KHR_android_surface_swapchain_SPEC_VERSION 4
|
||||
#define XR_KHR_ANDROID_SURFACE_SWAPCHAIN_EXTENSION_NAME "XR_KHR_android_surface_swapchain"
|
||||
typedef XrResult (XRAPI_PTR *PFN_xrCreateSwapchainAndroidSurfaceKHR)(XrSession session, const XrSwapchainCreateInfo* info, XrSwapchain* swapchain, jobject* surface);
|
||||
|
||||
#ifndef XR_NO_PROTOTYPES
|
||||
#ifdef XR_EXTENSION_PROTOTYPES
|
||||
XRAPI_ATTR XrResult XRAPI_CALL xrCreateSwapchainAndroidSurfaceKHR(
|
||||
XrSession session,
|
||||
const XrSwapchainCreateInfo* info,
|
||||
XrSwapchain* swapchain,
|
||||
jobject* surface);
|
||||
#endif /* XR_EXTENSION_PROTOTYPES */
|
||||
#endif /* !XR_NO_PROTOTYPES */
|
||||
#endif /* XR_USE_PLATFORM_ANDROID */
|
||||
|
||||
#ifdef XR_USE_PLATFORM_ANDROID
|
||||
|
||||
// XR_KHR_android_create_instance is a preprocessor guard. Do not pass it to API calls.
|
||||
#define XR_KHR_android_create_instance 1
|
||||
#define XR_KHR_android_create_instance_SPEC_VERSION 3
|
||||
#define XR_KHR_ANDROID_CREATE_INSTANCE_EXTENSION_NAME "XR_KHR_android_create_instance"
|
||||
// XrInstanceCreateInfoAndroidKHR extends XrInstanceCreateInfo
|
||||
typedef struct XrInstanceCreateInfoAndroidKHR {
|
||||
XrStructureType type;
|
||||
const void* XR_MAY_ALIAS next;
|
||||
void* XR_MAY_ALIAS applicationVM;
|
||||
void* XR_MAY_ALIAS applicationActivity;
|
||||
} XrInstanceCreateInfoAndroidKHR;
|
||||
|
||||
#endif /* XR_USE_PLATFORM_ANDROID */
|
||||
|
||||
#ifdef XR_USE_GRAPHICS_API_VULKAN
|
||||
|
||||
// XR_KHR_vulkan_swapchain_format_list is a preprocessor guard. Do not pass it to API calls.
|
||||
#define XR_KHR_vulkan_swapchain_format_list 1
|
||||
#define XR_KHR_vulkan_swapchain_format_list_SPEC_VERSION 5
|
||||
#define XR_KHR_VULKAN_SWAPCHAIN_FORMAT_LIST_EXTENSION_NAME "XR_KHR_vulkan_swapchain_format_list"
|
||||
// XrVulkanSwapchainFormatListCreateInfoKHR extends XrSwapchainCreateInfo
|
||||
typedef struct XrVulkanSwapchainFormatListCreateInfoKHR {
|
||||
XrStructureType type;
|
||||
const void* XR_MAY_ALIAS next;
|
||||
uint32_t viewFormatCount;
|
||||
const VkFormat* viewFormats;
|
||||
} XrVulkanSwapchainFormatListCreateInfoKHR;
|
||||
|
||||
#endif /* XR_USE_GRAPHICS_API_VULKAN */
|
||||
|
||||
#ifdef XR_USE_GRAPHICS_API_OPENGL
|
||||
|
||||
// XR_KHR_opengl_enable is a preprocessor guard. Do not pass it to API calls.
|
||||
#define XR_KHR_opengl_enable 1
|
||||
#define XR_KHR_opengl_enable_SPEC_VERSION 12
|
||||
#define XR_KHR_OPENGL_ENABLE_EXTENSION_NAME "XR_KHR_opengl_enable"
|
||||
#ifdef XR_USE_PLATFORM_WIN32
|
||||
// XrGraphicsBindingOpenGLWin32KHR extends XrSessionCreateInfo
|
||||
typedef struct XrGraphicsBindingOpenGLWin32KHR {
|
||||
XrStructureType type;
|
||||
const void* XR_MAY_ALIAS next;
|
||||
HDC hDC;
|
||||
HGLRC hGLRC;
|
||||
} XrGraphicsBindingOpenGLWin32KHR;
|
||||
#endif // XR_USE_PLATFORM_WIN32
|
||||
|
||||
#ifdef XR_USE_PLATFORM_XLIB
|
||||
// XrGraphicsBindingOpenGLXlibKHR extends XrSessionCreateInfo
|
||||
typedef struct XrGraphicsBindingOpenGLXlibKHR {
|
||||
XrStructureType type;
|
||||
const void* XR_MAY_ALIAS next;
|
||||
Display* xDisplay;
|
||||
uint32_t visualid;
|
||||
GLXFBConfig glxFBConfig;
|
||||
GLXDrawable glxDrawable;
|
||||
GLXContext glxContext;
|
||||
} XrGraphicsBindingOpenGLXlibKHR;
|
||||
#endif // XR_USE_PLATFORM_XLIB
|
||||
|
||||
#ifdef XR_USE_PLATFORM_XCB
|
||||
// XrGraphicsBindingOpenGLXcbKHR extends XrSessionCreateInfo
|
||||
typedef struct XrGraphicsBindingOpenGLXcbKHR {
|
||||
XrStructureType type;
|
||||
const void* XR_MAY_ALIAS next;
|
||||
xcb_connection_t* connection;
|
||||
uint32_t screenNumber;
|
||||
xcb_glx_fbconfig_t fbconfigid;
|
||||
xcb_visualid_t visualid;
|
||||
xcb_glx_drawable_t glxDrawable;
|
||||
xcb_glx_context_t glxContext;
|
||||
} XrGraphicsBindingOpenGLXcbKHR;
|
||||
#endif // XR_USE_PLATFORM_XCB
|
||||
|
||||
#ifdef XR_USE_PLATFORM_WAYLAND
|
||||
// XrGraphicsBindingOpenGLWaylandKHR extends XrSessionCreateInfo
|
||||
typedef struct XrGraphicsBindingOpenGLWaylandKHR {
|
||||
XrStructureType type;
|
||||
const void* XR_MAY_ALIAS next;
|
||||
struct wl_display* display;
|
||||
} XrGraphicsBindingOpenGLWaylandKHR;
|
||||
#endif // XR_USE_PLATFORM_WAYLAND
|
||||
|
||||
typedef struct XrSwapchainImageOpenGLKHR {
|
||||
XrStructureType type;
|
||||
void* XR_MAY_ALIAS next;
|
||||
uint32_t image;
|
||||
} XrSwapchainImageOpenGLKHR;
|
||||
|
||||
typedef struct XrGraphicsRequirementsOpenGLKHR {
|
||||
XrStructureType type;
|
||||
void* XR_MAY_ALIAS next;
|
||||
XrVersion minApiVersionSupported;
|
||||
XrVersion maxApiVersionSupported;
|
||||
} XrGraphicsRequirementsOpenGLKHR;
|
||||
|
||||
typedef XrResult (XRAPI_PTR *PFN_xrGetOpenGLGraphicsRequirementsKHR)(XrInstance instance, XrSystemId systemId, XrGraphicsRequirementsOpenGLKHR* graphicsRequirements);
|
||||
|
||||
#ifndef XR_NO_PROTOTYPES
|
||||
#ifdef XR_EXTENSION_PROTOTYPES
|
||||
XRAPI_ATTR XrResult XRAPI_CALL xrGetOpenGLGraphicsRequirementsKHR(
|
||||
XrInstance instance,
|
||||
XrSystemId systemId,
|
||||
XrGraphicsRequirementsOpenGLKHR* graphicsRequirements);
|
||||
#endif /* XR_EXTENSION_PROTOTYPES */
|
||||
#endif /* !XR_NO_PROTOTYPES */
|
||||
#endif /* XR_USE_GRAPHICS_API_OPENGL */
|
||||
|
||||
#ifdef XR_USE_GRAPHICS_API_OPENGL_ES
|
||||
|
||||
// XR_KHR_opengl_es_enable is a preprocessor guard. Do not pass it to API calls.
|
||||
#define XR_KHR_opengl_es_enable 1
|
||||
#define XR_KHR_opengl_es_enable_SPEC_VERSION 10
|
||||
#define XR_KHR_OPENGL_ES_ENABLE_EXTENSION_NAME "XR_KHR_opengl_es_enable"
|
||||
#ifdef XR_USE_PLATFORM_ANDROID
|
||||
// XrGraphicsBindingOpenGLESAndroidKHR extends XrSessionCreateInfo
|
||||
typedef struct XrGraphicsBindingOpenGLESAndroidKHR {
|
||||
XrStructureType type;
|
||||
const void* XR_MAY_ALIAS next;
|
||||
EGLDisplay display;
|
||||
EGLConfig config;
|
||||
EGLContext context;
|
||||
} XrGraphicsBindingOpenGLESAndroidKHR;
|
||||
#endif // XR_USE_PLATFORM_ANDROID
|
||||
|
||||
typedef struct XrSwapchainImageOpenGLESKHR {
|
||||
XrStructureType type;
|
||||
void* XR_MAY_ALIAS next;
|
||||
uint32_t image;
|
||||
} XrSwapchainImageOpenGLESKHR;
|
||||
|
||||
typedef struct XrGraphicsRequirementsOpenGLESKHR {
|
||||
XrStructureType type;
|
||||
void* XR_MAY_ALIAS next;
|
||||
XrVersion minApiVersionSupported;
|
||||
XrVersion maxApiVersionSupported;
|
||||
} XrGraphicsRequirementsOpenGLESKHR;
|
||||
|
||||
typedef XrResult (XRAPI_PTR *PFN_xrGetOpenGLESGraphicsRequirementsKHR)(XrInstance instance, XrSystemId systemId, XrGraphicsRequirementsOpenGLESKHR* graphicsRequirements);
|
||||
|
||||
#ifndef XR_NO_PROTOTYPES
|
||||
#ifdef XR_EXTENSION_PROTOTYPES
|
||||
XRAPI_ATTR XrResult XRAPI_CALL xrGetOpenGLESGraphicsRequirementsKHR(
|
||||
XrInstance instance,
|
||||
XrSystemId systemId,
|
||||
XrGraphicsRequirementsOpenGLESKHR* graphicsRequirements);
|
||||
#endif /* XR_EXTENSION_PROTOTYPES */
|
||||
#endif /* !XR_NO_PROTOTYPES */
|
||||
#endif /* XR_USE_GRAPHICS_API_OPENGL_ES */
|
||||
|
||||
#ifdef XR_USE_GRAPHICS_API_VULKAN
|
||||
|
||||
// XR_KHR_vulkan_enable is a preprocessor guard. Do not pass it to API calls.
|
||||
#define XR_KHR_vulkan_enable 1
|
||||
#define XR_KHR_vulkan_enable_SPEC_VERSION 10
|
||||
#define XR_KHR_VULKAN_ENABLE_EXTENSION_NAME "XR_KHR_vulkan_enable"
|
||||
// XrGraphicsBindingVulkanKHR extends XrSessionCreateInfo
|
||||
typedef struct XrGraphicsBindingVulkanKHR {
|
||||
XrStructureType type;
|
||||
const void* XR_MAY_ALIAS next;
|
||||
VkInstance instance;
|
||||
VkPhysicalDevice physicalDevice;
|
||||
VkDevice device;
|
||||
uint32_t queueFamilyIndex;
|
||||
uint32_t queueIndex;
|
||||
} XrGraphicsBindingVulkanKHR;
|
||||
|
||||
typedef struct XrSwapchainImageVulkanKHR {
|
||||
XrStructureType type;
|
||||
void* XR_MAY_ALIAS next;
|
||||
VkImage image;
|
||||
} XrSwapchainImageVulkanKHR;
|
||||
|
||||
typedef struct XrGraphicsRequirementsVulkanKHR {
|
||||
XrStructureType type;
|
||||
void* XR_MAY_ALIAS next;
|
||||
XrVersion minApiVersionSupported;
|
||||
XrVersion maxApiVersionSupported;
|
||||
} XrGraphicsRequirementsVulkanKHR;
|
||||
|
||||
typedef XrResult (XRAPI_PTR *PFN_xrGetVulkanInstanceExtensionsKHR)(XrInstance instance, XrSystemId systemId, uint32_t bufferCapacityInput, uint32_t* bufferCountOutput, char* buffer);
|
||||
typedef XrResult (XRAPI_PTR *PFN_xrGetVulkanDeviceExtensionsKHR)(XrInstance instance, XrSystemId systemId, uint32_t bufferCapacityInput, uint32_t* bufferCountOutput, char* buffer);
|
||||
typedef XrResult (XRAPI_PTR *PFN_xrGetVulkanGraphicsDeviceKHR)(XrInstance instance, XrSystemId systemId, VkInstance vkInstance, VkPhysicalDevice* vkPhysicalDevice);
|
||||
typedef XrResult (XRAPI_PTR *PFN_xrGetVulkanGraphicsRequirementsKHR)(XrInstance instance, XrSystemId systemId, XrGraphicsRequirementsVulkanKHR* graphicsRequirements);
|
||||
|
||||
#ifndef XR_NO_PROTOTYPES
|
||||
#ifdef XR_EXTENSION_PROTOTYPES
|
||||
XRAPI_ATTR XrResult XRAPI_CALL xrGetVulkanInstanceExtensionsKHR(
|
||||
XrInstance instance,
|
||||
XrSystemId systemId,
|
||||
uint32_t bufferCapacityInput,
|
||||
uint32_t* bufferCountOutput,
|
||||
char* buffer);
|
||||
|
||||
XRAPI_ATTR XrResult XRAPI_CALL xrGetVulkanDeviceExtensionsKHR(
|
||||
XrInstance instance,
|
||||
XrSystemId systemId,
|
||||
uint32_t bufferCapacityInput,
|
||||
uint32_t* bufferCountOutput,
|
||||
char* buffer);
|
||||
|
||||
XRAPI_ATTR XrResult XRAPI_CALL xrGetVulkanGraphicsDeviceKHR(
|
||||
XrInstance instance,
|
||||
XrSystemId systemId,
|
||||
VkInstance vkInstance,
|
||||
VkPhysicalDevice* vkPhysicalDevice);
|
||||
|
||||
XRAPI_ATTR XrResult XRAPI_CALL xrGetVulkanGraphicsRequirementsKHR(
|
||||
XrInstance instance,
|
||||
XrSystemId systemId,
|
||||
XrGraphicsRequirementsVulkanKHR* graphicsRequirements);
|
||||
#endif /* XR_EXTENSION_PROTOTYPES */
|
||||
#endif /* !XR_NO_PROTOTYPES */
|
||||
#endif /* XR_USE_GRAPHICS_API_VULKAN */
|
||||
|
||||
#ifdef XR_USE_GRAPHICS_API_D3D11
|
||||
|
||||
// XR_KHR_D3D11_enable is a preprocessor guard. Do not pass it to API calls.
|
||||
#define XR_KHR_D3D11_enable 1
|
||||
#define XR_KHR_D3D11_enable_SPEC_VERSION 11
|
||||
#define XR_KHR_D3D11_ENABLE_EXTENSION_NAME "XR_KHR_D3D11_enable"
|
||||
// XrGraphicsBindingD3D11KHR extends XrSessionCreateInfo
|
||||
typedef struct XrGraphicsBindingD3D11KHR {
|
||||
XrStructureType type;
|
||||
const void* XR_MAY_ALIAS next;
|
||||
ID3D11Device* device;
|
||||
} XrGraphicsBindingD3D11KHR;
|
||||
|
||||
typedef struct XrSwapchainImageD3D11KHR {
|
||||
XrStructureType type;
|
||||
void* XR_MAY_ALIAS next;
|
||||
ID3D11Texture2D* texture;
|
||||
} XrSwapchainImageD3D11KHR;
|
||||
|
||||
typedef struct XrGraphicsRequirementsD3D11KHR {
|
||||
XrStructureType type;
|
||||
void* XR_MAY_ALIAS next;
|
||||
LUID adapterLuid;
|
||||
D3D_FEATURE_LEVEL minFeatureLevel;
|
||||
} XrGraphicsRequirementsD3D11KHR;
|
||||
|
||||
typedef XrResult (XRAPI_PTR *PFN_xrGetD3D11GraphicsRequirementsKHR)(XrInstance instance, XrSystemId systemId, XrGraphicsRequirementsD3D11KHR* graphicsRequirements);
|
||||
|
||||
#ifndef XR_NO_PROTOTYPES
|
||||
#ifdef XR_EXTENSION_PROTOTYPES
|
||||
XRAPI_ATTR XrResult XRAPI_CALL xrGetD3D11GraphicsRequirementsKHR(
|
||||
XrInstance instance,
|
||||
XrSystemId systemId,
|
||||
XrGraphicsRequirementsD3D11KHR* graphicsRequirements);
|
||||
#endif /* XR_EXTENSION_PROTOTYPES */
|
||||
#endif /* !XR_NO_PROTOTYPES */
|
||||
#endif /* XR_USE_GRAPHICS_API_D3D11 */
|
||||
|
||||
#ifdef XR_USE_GRAPHICS_API_D3D12
|
||||
|
||||
// XR_KHR_D3D12_enable is a preprocessor guard. Do not pass it to API calls.
|
||||
#define XR_KHR_D3D12_enable 1
|
||||
#define XR_KHR_D3D12_enable_SPEC_VERSION 11
|
||||
#define XR_KHR_D3D12_ENABLE_EXTENSION_NAME "XR_KHR_D3D12_enable"
|
||||
// XrGraphicsBindingD3D12KHR extends XrSessionCreateInfo
|
||||
typedef struct XrGraphicsBindingD3D12KHR {
|
||||
XrStructureType type;
|
||||
const void* XR_MAY_ALIAS next;
|
||||
ID3D12Device* device;
|
||||
ID3D12CommandQueue* queue;
|
||||
} XrGraphicsBindingD3D12KHR;
|
||||
|
||||
typedef struct XrSwapchainImageD3D12KHR {
|
||||
XrStructureType type;
|
||||
void* XR_MAY_ALIAS next;
|
||||
ID3D12Resource* texture;
|
||||
} XrSwapchainImageD3D12KHR;
|
||||
|
||||
typedef struct XrGraphicsRequirementsD3D12KHR {
|
||||
XrStructureType type;
|
||||
void* XR_MAY_ALIAS next;
|
||||
LUID adapterLuid;
|
||||
D3D_FEATURE_LEVEL minFeatureLevel;
|
||||
} XrGraphicsRequirementsD3D12KHR;
|
||||
|
||||
typedef XrResult (XRAPI_PTR *PFN_xrGetD3D12GraphicsRequirementsKHR)(XrInstance instance, XrSystemId systemId, XrGraphicsRequirementsD3D12KHR* graphicsRequirements);
|
||||
|
||||
#ifndef XR_NO_PROTOTYPES
|
||||
#ifdef XR_EXTENSION_PROTOTYPES
|
||||
XRAPI_ATTR XrResult XRAPI_CALL xrGetD3D12GraphicsRequirementsKHR(
|
||||
XrInstance instance,
|
||||
XrSystemId systemId,
|
||||
XrGraphicsRequirementsD3D12KHR* graphicsRequirements);
|
||||
#endif /* XR_EXTENSION_PROTOTYPES */
|
||||
#endif /* !XR_NO_PROTOTYPES */
|
||||
#endif /* XR_USE_GRAPHICS_API_D3D12 */
|
||||
|
||||
#ifdef XR_USE_GRAPHICS_API_METAL
|
||||
|
||||
// XR_KHR_metal_enable is a preprocessor guard. Do not pass it to API calls.
|
||||
#define XR_KHR_metal_enable 1
|
||||
#define XR_KHR_metal_enable_SPEC_VERSION 3
|
||||
#define XR_KHR_METAL_ENABLE_EXTENSION_NAME "XR_KHR_metal_enable"
|
||||
// XrGraphicsBindingMetalKHR extends XrSessionCreateInfo
|
||||
typedef struct XrGraphicsBindingMetalKHR {
|
||||
XrStructureType type;
|
||||
const void* XR_MAY_ALIAS next;
|
||||
void* XR_MAY_ALIAS commandQueue;
|
||||
} XrGraphicsBindingMetalKHR;
|
||||
|
||||
typedef struct XrSwapchainImageMetalKHR {
|
||||
XrStructureType type;
|
||||
void* XR_MAY_ALIAS next;
|
||||
void* XR_MAY_ALIAS texture;
|
||||
} XrSwapchainImageMetalKHR;
|
||||
|
||||
typedef struct XrGraphicsRequirementsMetalKHR {
|
||||
XrStructureType type;
|
||||
void* XR_MAY_ALIAS next;
|
||||
void* XR_MAY_ALIAS metalDevice;
|
||||
} XrGraphicsRequirementsMetalKHR;
|
||||
|
||||
typedef XrResult (XRAPI_PTR *PFN_xrGetMetalGraphicsRequirementsKHR)(XrInstance instance, XrSystemId systemId, XrGraphicsRequirementsMetalKHR* graphicsRequirements);
|
||||
|
||||
#ifndef XR_NO_PROTOTYPES
|
||||
#ifdef XR_EXTENSION_PROTOTYPES
|
||||
XRAPI_ATTR XrResult XRAPI_CALL xrGetMetalGraphicsRequirementsKHR(
|
||||
XrInstance instance,
|
||||
XrSystemId systemId,
|
||||
XrGraphicsRequirementsMetalKHR* graphicsRequirements);
|
||||
#endif /* XR_EXTENSION_PROTOTYPES */
|
||||
#endif /* !XR_NO_PROTOTYPES */
|
||||
#endif /* XR_USE_GRAPHICS_API_METAL */
|
||||
|
||||
#ifdef XR_USE_PLATFORM_WIN32
|
||||
|
||||
// XR_KHR_win32_convert_performance_counter_time is a preprocessor guard. Do not pass it to API calls.
|
||||
#define XR_KHR_win32_convert_performance_counter_time 1
|
||||
#define XR_KHR_win32_convert_performance_counter_time_SPEC_VERSION 1
|
||||
#define XR_KHR_WIN32_CONVERT_PERFORMANCE_COUNTER_TIME_EXTENSION_NAME "XR_KHR_win32_convert_performance_counter_time"
|
||||
typedef XrResult (XRAPI_PTR *PFN_xrConvertWin32PerformanceCounterToTimeKHR)(XrInstance instance, const LARGE_INTEGER* performanceCounter, XrTime* time);
|
||||
typedef XrResult (XRAPI_PTR *PFN_xrConvertTimeToWin32PerformanceCounterKHR)(XrInstance instance, XrTime time, LARGE_INTEGER* performanceCounter);
|
||||
|
||||
#ifndef XR_NO_PROTOTYPES
|
||||
#ifdef XR_EXTENSION_PROTOTYPES
|
||||
XRAPI_ATTR XrResult XRAPI_CALL xrConvertWin32PerformanceCounterToTimeKHR(
|
||||
XrInstance instance,
|
||||
const LARGE_INTEGER* performanceCounter,
|
||||
XrTime* time);
|
||||
|
||||
XRAPI_ATTR XrResult XRAPI_CALL xrConvertTimeToWin32PerformanceCounterKHR(
|
||||
XrInstance instance,
|
||||
XrTime time,
|
||||
LARGE_INTEGER* performanceCounter);
|
||||
#endif /* XR_EXTENSION_PROTOTYPES */
|
||||
#endif /* !XR_NO_PROTOTYPES */
|
||||
#endif /* XR_USE_PLATFORM_WIN32 */
|
||||
|
||||
#ifdef XR_USE_TIMESPEC
|
||||
|
||||
// XR_KHR_convert_timespec_time is a preprocessor guard. Do not pass it to API calls.
|
||||
#define XR_KHR_convert_timespec_time 1
|
||||
#define XR_KHR_convert_timespec_time_SPEC_VERSION 1
|
||||
#define XR_KHR_CONVERT_TIMESPEC_TIME_EXTENSION_NAME "XR_KHR_convert_timespec_time"
|
||||
typedef XrResult (XRAPI_PTR *PFN_xrConvertTimespecTimeToTimeKHR)(XrInstance instance, const struct timespec* timespecTime, XrTime* time);
|
||||
typedef XrResult (XRAPI_PTR *PFN_xrConvertTimeToTimespecTimeKHR)(XrInstance instance, XrTime time, struct timespec* timespecTime);
|
||||
|
||||
#ifndef XR_NO_PROTOTYPES
|
||||
#ifdef XR_EXTENSION_PROTOTYPES
|
||||
XRAPI_ATTR XrResult XRAPI_CALL xrConvertTimespecTimeToTimeKHR(
|
||||
XrInstance instance,
|
||||
const struct timespec* timespecTime,
|
||||
XrTime* time);
|
||||
|
||||
XRAPI_ATTR XrResult XRAPI_CALL xrConvertTimeToTimespecTimeKHR(
|
||||
XrInstance instance,
|
||||
XrTime time,
|
||||
struct timespec* timespecTime);
|
||||
#endif /* XR_EXTENSION_PROTOTYPES */
|
||||
#endif /* !XR_NO_PROTOTYPES */
|
||||
#endif /* XR_USE_TIMESPEC */
|
||||
|
||||
#ifdef XR_USE_PLATFORM_ANDROID
|
||||
|
||||
// XR_KHR_loader_init_android is a preprocessor guard. Do not pass it to API calls.
|
||||
#define XR_KHR_loader_init_android 1
|
||||
#define XR_KHR_loader_init_android_SPEC_VERSION 1
|
||||
#define XR_KHR_LOADER_INIT_ANDROID_EXTENSION_NAME "XR_KHR_loader_init_android"
|
||||
typedef struct XrLoaderInitInfoAndroidKHR {
|
||||
XrStructureType type;
|
||||
const void* XR_MAY_ALIAS next;
|
||||
void* XR_MAY_ALIAS applicationVM;
|
||||
void* XR_MAY_ALIAS applicationContext;
|
||||
} XrLoaderInitInfoAndroidKHR;
|
||||
|
||||
#endif /* XR_USE_PLATFORM_ANDROID */
|
||||
|
||||
#ifdef XR_USE_GRAPHICS_API_VULKAN
|
||||
|
||||
// XR_KHR_vulkan_enable2 is a preprocessor guard. Do not pass it to API calls.
|
||||
#define XR_KHR_vulkan_enable2 1
|
||||
#define XR_KHR_vulkan_enable2_SPEC_VERSION 4
|
||||
#define XR_KHR_VULKAN_ENABLE2_EXTENSION_NAME "XR_KHR_vulkan_enable2"
|
||||
typedef XrFlags64 XrVulkanInstanceCreateFlagsKHR;
|
||||
|
||||
// Flag bits for XrVulkanInstanceCreateFlagsKHR
|
||||
|
||||
typedef XrFlags64 XrVulkanDeviceCreateFlagsKHR;
|
||||
|
||||
// Flag bits for XrVulkanDeviceCreateFlagsKHR
|
||||
|
||||
typedef struct XrVulkanInstanceCreateInfoKHR {
|
||||
XrStructureType type;
|
||||
const void* XR_MAY_ALIAS next;
|
||||
XrSystemId systemId;
|
||||
XrVulkanInstanceCreateFlagsKHR createFlags;
|
||||
PFN_vkGetInstanceProcAddr pfnGetInstanceProcAddr;
|
||||
const VkInstanceCreateInfo* vulkanCreateInfo;
|
||||
const VkAllocationCallbacks* vulkanAllocator;
|
||||
} XrVulkanInstanceCreateInfoKHR;
|
||||
|
||||
typedef struct XrVulkanDeviceCreateInfoKHR {
|
||||
XrStructureType type;
|
||||
const void* XR_MAY_ALIAS next;
|
||||
XrSystemId systemId;
|
||||
XrVulkanDeviceCreateFlagsKHR createFlags;
|
||||
PFN_vkGetInstanceProcAddr pfnGetInstanceProcAddr;
|
||||
VkPhysicalDevice vulkanPhysicalDevice;
|
||||
const VkDeviceCreateInfo* vulkanCreateInfo;
|
||||
const VkAllocationCallbacks* vulkanAllocator;
|
||||
} XrVulkanDeviceCreateInfoKHR;
|
||||
|
||||
typedef XrGraphicsBindingVulkanKHR XrGraphicsBindingVulkan2KHR;
|
||||
|
||||
typedef struct XrVulkanGraphicsDeviceGetInfoKHR {
|
||||
XrStructureType type;
|
||||
const void* XR_MAY_ALIAS next;
|
||||
XrSystemId systemId;
|
||||
VkInstance vulkanInstance;
|
||||
} XrVulkanGraphicsDeviceGetInfoKHR;
|
||||
|
||||
typedef XrSwapchainImageVulkanKHR XrSwapchainImageVulkan2KHR;
|
||||
|
||||
typedef XrGraphicsRequirementsVulkanKHR XrGraphicsRequirementsVulkan2KHR;
|
||||
|
||||
typedef XrResult (XRAPI_PTR *PFN_xrCreateVulkanInstanceKHR)(XrInstance instance, const XrVulkanInstanceCreateInfoKHR* createInfo, VkInstance* vulkanInstance, VkResult* vulkanResult);
|
||||
typedef XrResult (XRAPI_PTR *PFN_xrCreateVulkanDeviceKHR)(XrInstance instance, const XrVulkanDeviceCreateInfoKHR* createInfo, VkDevice* vulkanDevice, VkResult* vulkanResult);
|
||||
typedef XrResult (XRAPI_PTR *PFN_xrGetVulkanGraphicsDevice2KHR)(XrInstance instance, const XrVulkanGraphicsDeviceGetInfoKHR* getInfo, VkPhysicalDevice* vulkanPhysicalDevice);
|
||||
typedef XrResult (XRAPI_PTR *PFN_xrGetVulkanGraphicsRequirements2KHR)(XrInstance instance, XrSystemId systemId, XrGraphicsRequirementsVulkanKHR* graphicsRequirements);
|
||||
|
||||
#ifndef XR_NO_PROTOTYPES
|
||||
#ifdef XR_EXTENSION_PROTOTYPES
|
||||
XRAPI_ATTR XrResult XRAPI_CALL xrCreateVulkanInstanceKHR(
|
||||
XrInstance instance,
|
||||
const XrVulkanInstanceCreateInfoKHR* createInfo,
|
||||
VkInstance* vulkanInstance,
|
||||
VkResult* vulkanResult);
|
||||
|
||||
XRAPI_ATTR XrResult XRAPI_CALL xrCreateVulkanDeviceKHR(
|
||||
XrInstance instance,
|
||||
const XrVulkanDeviceCreateInfoKHR* createInfo,
|
||||
VkDevice* vulkanDevice,
|
||||
VkResult* vulkanResult);
|
||||
|
||||
XRAPI_ATTR XrResult XRAPI_CALL xrGetVulkanGraphicsDevice2KHR(
|
||||
XrInstance instance,
|
||||
const XrVulkanGraphicsDeviceGetInfoKHR* getInfo,
|
||||
VkPhysicalDevice* vulkanPhysicalDevice);
|
||||
|
||||
XRAPI_ATTR XrResult XRAPI_CALL xrGetVulkanGraphicsRequirements2KHR(
|
||||
XrInstance instance,
|
||||
XrSystemId systemId,
|
||||
XrGraphicsRequirementsVulkanKHR* graphicsRequirements);
|
||||
#endif /* XR_EXTENSION_PROTOTYPES */
|
||||
#endif /* !XR_NO_PROTOTYPES */
|
||||
#endif /* XR_USE_GRAPHICS_API_VULKAN */
|
||||
|
||||
#ifdef XR_USE_PLATFORM_EGL
|
||||
|
||||
// XR_MNDX_egl_enable is a preprocessor guard. Do not pass it to API calls.
|
||||
#define XR_MNDX_egl_enable 1
|
||||
#define XR_MNDX_egl_enable_SPEC_VERSION 2
|
||||
#define XR_MNDX_EGL_ENABLE_EXTENSION_NAME "XR_MNDX_egl_enable"
|
||||
typedef PFN_xrVoidFunction (*PFN_xrEglGetProcAddressMNDX)(const char *name);
|
||||
// XrGraphicsBindingEGLMNDX extends XrSessionCreateInfo
|
||||
typedef struct XrGraphicsBindingEGLMNDX {
|
||||
XrStructureType type;
|
||||
const void* XR_MAY_ALIAS next;
|
||||
PFN_xrEglGetProcAddressMNDX getProcAddress;
|
||||
EGLDisplay display;
|
||||
EGLConfig config;
|
||||
EGLContext context;
|
||||
} XrGraphicsBindingEGLMNDX;
|
||||
|
||||
#endif /* XR_USE_PLATFORM_EGL */
|
||||
|
||||
#ifdef XR_USE_PLATFORM_WIN32
|
||||
|
||||
// XR_MSFT_perception_anchor_interop is a preprocessor guard. Do not pass it to API calls.
|
||||
#define XR_MSFT_perception_anchor_interop 1
|
||||
#define XR_MSFT_perception_anchor_interop_SPEC_VERSION 1
|
||||
#define XR_MSFT_PERCEPTION_ANCHOR_INTEROP_EXTENSION_NAME "XR_MSFT_perception_anchor_interop"
|
||||
typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorFromPerceptionAnchorMSFT)(XrSession session, IUnknown* perceptionAnchor, XrSpatialAnchorMSFT* anchor);
|
||||
typedef XrResult (XRAPI_PTR *PFN_xrTryGetPerceptionAnchorFromSpatialAnchorMSFT)(XrSession session, XrSpatialAnchorMSFT anchor, IUnknown** perceptionAnchor);
|
||||
|
||||
#ifndef XR_NO_PROTOTYPES
|
||||
#ifdef XR_EXTENSION_PROTOTYPES
|
||||
XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialAnchorFromPerceptionAnchorMSFT(
|
||||
XrSession session,
|
||||
IUnknown* perceptionAnchor,
|
||||
XrSpatialAnchorMSFT* anchor);
|
||||
|
||||
XRAPI_ATTR XrResult XRAPI_CALL xrTryGetPerceptionAnchorFromSpatialAnchorMSFT(
|
||||
XrSession session,
|
||||
XrSpatialAnchorMSFT anchor,
|
||||
IUnknown** perceptionAnchor);
|
||||
#endif /* XR_EXTENSION_PROTOTYPES */
|
||||
#endif /* !XR_NO_PROTOTYPES */
|
||||
#endif /* XR_USE_PLATFORM_WIN32 */
|
||||
|
||||
#ifdef XR_USE_PLATFORM_WIN32
|
||||
|
||||
// XR_MSFT_holographic_window_attachment is a preprocessor guard. Do not pass it to API calls.
|
||||
#define XR_MSFT_holographic_window_attachment 1
|
||||
#define XR_MSFT_holographic_window_attachment_SPEC_VERSION 1
|
||||
#define XR_MSFT_HOLOGRAPHIC_WINDOW_ATTACHMENT_EXTENSION_NAME "XR_MSFT_holographic_window_attachment"
|
||||
#ifdef XR_USE_PLATFORM_WIN32
|
||||
// XrHolographicWindowAttachmentMSFT extends XrSessionCreateInfo
|
||||
typedef struct XrHolographicWindowAttachmentMSFT {
|
||||
XrStructureType type;
|
||||
const void* XR_MAY_ALIAS next;
|
||||
IUnknown* holographicSpace;
|
||||
IUnknown* coreWindow;
|
||||
} XrHolographicWindowAttachmentMSFT;
|
||||
#endif // XR_USE_PLATFORM_WIN32
|
||||
|
||||
#endif /* XR_USE_PLATFORM_WIN32 */
|
||||
|
||||
#ifdef XR_USE_PLATFORM_ANDROID
|
||||
|
||||
// XR_FB_android_surface_swapchain_create is a preprocessor guard. Do not pass it to API calls.
|
||||
#define XR_FB_android_surface_swapchain_create 1
|
||||
#define XR_FB_android_surface_swapchain_create_SPEC_VERSION 1
|
||||
#define XR_FB_ANDROID_SURFACE_SWAPCHAIN_CREATE_EXTENSION_NAME "XR_FB_android_surface_swapchain_create"
|
||||
typedef XrFlags64 XrAndroidSurfaceSwapchainFlagsFB;
|
||||
|
||||
// Flag bits for XrAndroidSurfaceSwapchainFlagsFB
|
||||
static const XrAndroidSurfaceSwapchainFlagsFB XR_ANDROID_SURFACE_SWAPCHAIN_SYNCHRONOUS_BIT_FB = 0x00000001;
|
||||
static const XrAndroidSurfaceSwapchainFlagsFB XR_ANDROID_SURFACE_SWAPCHAIN_USE_TIMESTAMPS_BIT_FB = 0x00000002;
|
||||
|
||||
#ifdef XR_USE_PLATFORM_ANDROID
|
||||
// XrAndroidSurfaceSwapchainCreateInfoFB extends XrSwapchainCreateInfo
|
||||
typedef struct XrAndroidSurfaceSwapchainCreateInfoFB {
|
||||
XrStructureType type;
|
||||
const void* XR_MAY_ALIAS next;
|
||||
XrAndroidSurfaceSwapchainFlagsFB createFlags;
|
||||
} XrAndroidSurfaceSwapchainCreateInfoFB;
|
||||
#endif // XR_USE_PLATFORM_ANDROID
|
||||
|
||||
#endif /* XR_USE_PLATFORM_ANDROID */
|
||||
|
||||
#ifdef XR_USE_PLATFORM_ML
|
||||
|
||||
// XR_ML_compat is a preprocessor guard. Do not pass it to API calls.
|
||||
#define XR_ML_compat 1
|
||||
#define XR_ML_compat_SPEC_VERSION 1
|
||||
#define XR_ML_COMPAT_EXTENSION_NAME "XR_ML_compat"
|
||||
typedef struct XrCoordinateSpaceCreateInfoML {
|
||||
XrStructureType type;
|
||||
const void* XR_MAY_ALIAS next;
|
||||
MLCoordinateFrameUID cfuid;
|
||||
XrPosef poseInCoordinateSpace;
|
||||
} XrCoordinateSpaceCreateInfoML;
|
||||
|
||||
typedef XrResult (XRAPI_PTR *PFN_xrCreateSpaceFromCoordinateFrameUIDML)(XrSession session, const XrCoordinateSpaceCreateInfoML *createInfo, XrSpace* space);
|
||||
|
||||
#ifndef XR_NO_PROTOTYPES
|
||||
#ifdef XR_EXTENSION_PROTOTYPES
|
||||
XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpaceFromCoordinateFrameUIDML(
|
||||
XrSession session,
|
||||
const XrCoordinateSpaceCreateInfoML * createInfo,
|
||||
XrSpace* space);
|
||||
#endif /* XR_EXTENSION_PROTOTYPES */
|
||||
#endif /* !XR_NO_PROTOTYPES */
|
||||
#endif /* XR_USE_PLATFORM_ML */
|
||||
|
||||
#ifdef XR_USE_PLATFORM_WIN32
|
||||
|
||||
// XR_OCULUS_audio_device_guid is a preprocessor guard. Do not pass it to API calls.
|
||||
#define XR_OCULUS_audio_device_guid 1
|
||||
#define XR_OCULUS_audio_device_guid_SPEC_VERSION 1
|
||||
#define XR_OCULUS_AUDIO_DEVICE_GUID_EXTENSION_NAME "XR_OCULUS_audio_device_guid"
|
||||
#define XR_MAX_AUDIO_DEVICE_STR_SIZE_OCULUS 128
|
||||
typedef XrResult (XRAPI_PTR *PFN_xrGetAudioOutputDeviceGuidOculus)(XrInstance instance, wchar_t buffer[XR_MAX_AUDIO_DEVICE_STR_SIZE_OCULUS]);
|
||||
typedef XrResult (XRAPI_PTR *PFN_xrGetAudioInputDeviceGuidOculus)(XrInstance instance, wchar_t buffer[XR_MAX_AUDIO_DEVICE_STR_SIZE_OCULUS]);
|
||||
|
||||
#ifndef XR_NO_PROTOTYPES
|
||||
#ifdef XR_EXTENSION_PROTOTYPES
|
||||
XRAPI_ATTR XrResult XRAPI_CALL xrGetAudioOutputDeviceGuidOculus(
|
||||
XrInstance instance,
|
||||
wchar_t buffer[XR_MAX_AUDIO_DEVICE_STR_SIZE_OCULUS]);
|
||||
|
||||
XRAPI_ATTR XrResult XRAPI_CALL xrGetAudioInputDeviceGuidOculus(
|
||||
XrInstance instance,
|
||||
wchar_t buffer[XR_MAX_AUDIO_DEVICE_STR_SIZE_OCULUS]);
|
||||
#endif /* XR_EXTENSION_PROTOTYPES */
|
||||
#endif /* !XR_NO_PROTOTYPES */
|
||||
#endif /* XR_USE_PLATFORM_WIN32 */
|
||||
|
||||
#ifdef XR_USE_GRAPHICS_API_VULKAN
|
||||
|
||||
// XR_FB_foveation_vulkan is a preprocessor guard. Do not pass it to API calls.
|
||||
#define XR_FB_foveation_vulkan 1
|
||||
#define XR_FB_foveation_vulkan_SPEC_VERSION 1
|
||||
#define XR_FB_FOVEATION_VULKAN_EXTENSION_NAME "XR_FB_foveation_vulkan"
|
||||
// XrSwapchainImageFoveationVulkanFB extends XrSwapchainImageVulkanKHR
|
||||
typedef struct XrSwapchainImageFoveationVulkanFB {
|
||||
XrStructureType type;
|
||||
void* XR_MAY_ALIAS next;
|
||||
VkImage image;
|
||||
uint32_t width;
|
||||
uint32_t height;
|
||||
} XrSwapchainImageFoveationVulkanFB;
|
||||
|
||||
#endif /* XR_USE_GRAPHICS_API_VULKAN */
|
||||
|
||||
#ifdef XR_USE_PLATFORM_ANDROID
|
||||
|
||||
// XR_FB_swapchain_update_state_android_surface is a preprocessor guard. Do not pass it to API calls.
|
||||
#define XR_FB_swapchain_update_state_android_surface 1
|
||||
#define XR_FB_swapchain_update_state_android_surface_SPEC_VERSION 1
|
||||
#define XR_FB_SWAPCHAIN_UPDATE_STATE_ANDROID_SURFACE_EXTENSION_NAME "XR_FB_swapchain_update_state_android_surface"
|
||||
#ifdef XR_USE_PLATFORM_ANDROID
|
||||
typedef struct XrSwapchainStateAndroidSurfaceDimensionsFB {
|
||||
XrStructureType type;
|
||||
void* XR_MAY_ALIAS next;
|
||||
uint32_t width;
|
||||
uint32_t height;
|
||||
} XrSwapchainStateAndroidSurfaceDimensionsFB;
|
||||
#endif // XR_USE_PLATFORM_ANDROID
|
||||
|
||||
#endif /* XR_USE_PLATFORM_ANDROID */
|
||||
|
||||
#ifdef XR_USE_GRAPHICS_API_OPENGL_ES
|
||||
|
||||
// XR_FB_swapchain_update_state_opengl_es is a preprocessor guard. Do not pass it to API calls.
|
||||
#define XR_FB_swapchain_update_state_opengl_es 1
|
||||
#define XR_FB_swapchain_update_state_opengl_es_SPEC_VERSION 1
|
||||
#define XR_FB_SWAPCHAIN_UPDATE_STATE_OPENGL_ES_EXTENSION_NAME "XR_FB_swapchain_update_state_opengl_es"
|
||||
#ifdef XR_USE_GRAPHICS_API_OPENGL_ES
|
||||
typedef struct XrSwapchainStateSamplerOpenGLESFB {
|
||||
XrStructureType type;
|
||||
void* XR_MAY_ALIAS next;
|
||||
EGLenum minFilter;
|
||||
EGLenum magFilter;
|
||||
EGLenum wrapModeS;
|
||||
EGLenum wrapModeT;
|
||||
EGLenum swizzleRed;
|
||||
EGLenum swizzleGreen;
|
||||
EGLenum swizzleBlue;
|
||||
EGLenum swizzleAlpha;
|
||||
float maxAnisotropy;
|
||||
XrColor4f borderColor;
|
||||
} XrSwapchainStateSamplerOpenGLESFB;
|
||||
#endif // XR_USE_GRAPHICS_API_OPENGL_ES
|
||||
|
||||
#endif /* XR_USE_GRAPHICS_API_OPENGL_ES */
|
||||
|
||||
#ifdef XR_USE_GRAPHICS_API_VULKAN
|
||||
|
||||
// XR_FB_swapchain_update_state_vulkan is a preprocessor guard. Do not pass it to API calls.
|
||||
#define XR_FB_swapchain_update_state_vulkan 1
|
||||
#define XR_FB_swapchain_update_state_vulkan_SPEC_VERSION 1
|
||||
#define XR_FB_SWAPCHAIN_UPDATE_STATE_VULKAN_EXTENSION_NAME "XR_FB_swapchain_update_state_vulkan"
|
||||
#ifdef XR_USE_GRAPHICS_API_VULKAN
|
||||
typedef struct XrSwapchainStateSamplerVulkanFB {
|
||||
XrStructureType type;
|
||||
void* XR_MAY_ALIAS next;
|
||||
VkFilter minFilter;
|
||||
VkFilter magFilter;
|
||||
VkSamplerMipmapMode mipmapMode;
|
||||
VkSamplerAddressMode wrapModeS;
|
||||
VkSamplerAddressMode wrapModeT;
|
||||
VkComponentSwizzle swizzleRed;
|
||||
VkComponentSwizzle swizzleGreen;
|
||||
VkComponentSwizzle swizzleBlue;
|
||||
VkComponentSwizzle swizzleAlpha;
|
||||
float maxAnisotropy;
|
||||
XrColor4f borderColor;
|
||||
} XrSwapchainStateSamplerVulkanFB;
|
||||
#endif // XR_USE_GRAPHICS_API_VULKAN
|
||||
|
||||
#endif /* XR_USE_GRAPHICS_API_VULKAN */
|
||||
|
||||
#ifdef XR_USE_GRAPHICS_API_VULKAN
|
||||
|
||||
// XR_META_vulkan_swapchain_create_info is a preprocessor guard. Do not pass it to API calls.
|
||||
#define XR_META_vulkan_swapchain_create_info 1
|
||||
#define XR_META_vulkan_swapchain_create_info_SPEC_VERSION 1
|
||||
#define XR_META_VULKAN_SWAPCHAIN_CREATE_INFO_EXTENSION_NAME "XR_META_vulkan_swapchain_create_info"
|
||||
// XrVulkanSwapchainCreateInfoMETA extends XrSwapchainCreateInfo
|
||||
typedef struct XrVulkanSwapchainCreateInfoMETA {
|
||||
XrStructureType type;
|
||||
const void* XR_MAY_ALIAS next;
|
||||
VkImageCreateFlags additionalCreateFlags;
|
||||
VkImageUsageFlags additionalUsageFlags;
|
||||
} XrVulkanSwapchainCreateInfoMETA;
|
||||
|
||||
#endif /* XR_USE_GRAPHICS_API_VULKAN */
|
||||
|
||||
#ifdef XR_USE_PLATFORM_ANDROID
|
||||
|
||||
// XR_ANDROID_anchor_sharing_export is a preprocessor guard. Do not pass it to API calls.
|
||||
#define XR_ANDROID_anchor_sharing_export 1
|
||||
#define XR_ANDROID_anchor_sharing_export_SPEC_VERSION 1
|
||||
#define XR_ANDROID_ANCHOR_SHARING_EXPORT_EXTENSION_NAME "XR_ANDROID_anchor_sharing_export"
|
||||
typedef struct XrAnchorSharingInfoANDROID {
|
||||
XrStructureType type;
|
||||
const void* XR_MAY_ALIAS next;
|
||||
XrSpace anchor;
|
||||
} XrAnchorSharingInfoANDROID;
|
||||
|
||||
typedef struct XrAnchorSharingTokenANDROID {
|
||||
XrStructureType type;
|
||||
void* XR_MAY_ALIAS next;
|
||||
struct AIBinder* token;
|
||||
} XrAnchorSharingTokenANDROID;
|
||||
|
||||
// XrSystemAnchorSharingExportPropertiesANDROID extends XrSystemProperties
|
||||
typedef struct XrSystemAnchorSharingExportPropertiesANDROID {
|
||||
XrStructureType type;
|
||||
void* XR_MAY_ALIAS next;
|
||||
XrBool32 supportsAnchorSharingExport;
|
||||
} XrSystemAnchorSharingExportPropertiesANDROID;
|
||||
|
||||
typedef XrResult (XRAPI_PTR *PFN_xrShareAnchorANDROID)(XrSession session, const XrAnchorSharingInfoANDROID* sharingInfo, XrAnchorSharingTokenANDROID* anchorToken);
|
||||
typedef XrResult (XRAPI_PTR *PFN_xrUnshareAnchorANDROID)(XrSession session, XrSpace anchor);
|
||||
|
||||
#ifndef XR_NO_PROTOTYPES
|
||||
#ifdef XR_EXTENSION_PROTOTYPES
|
||||
XRAPI_ATTR XrResult XRAPI_CALL xrShareAnchorANDROID(
|
||||
XrSession session,
|
||||
const XrAnchorSharingInfoANDROID* sharingInfo,
|
||||
XrAnchorSharingTokenANDROID* anchorToken);
|
||||
|
||||
XRAPI_ATTR XrResult XRAPI_CALL xrUnshareAnchorANDROID(
|
||||
XrSession session,
|
||||
XrSpace anchor);
|
||||
#endif /* XR_EXTENSION_PROTOTYPES */
|
||||
#endif /* !XR_NO_PROTOTYPES */
|
||||
#endif /* XR_USE_PLATFORM_ANDROID */
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,114 @@
|
||||
/*
|
||||
** Copyright (c) 2017-2026 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0 OR MIT
|
||||
*/
|
||||
|
||||
#ifndef OPENXR_PLATFORM_DEFINES_H_
|
||||
#define OPENXR_PLATFORM_DEFINES_H_ 1
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* Platform-specific calling convention macros.
|
||||
*
|
||||
* Platforms should define these so that OpenXR clients call OpenXR functions
|
||||
* with the same calling conventions that the OpenXR implementation expects.
|
||||
*
|
||||
* XRAPI_ATTR - Placed before the return type in function declarations.
|
||||
* Useful for C++11 and GCC/Clang-style function attribute syntax.
|
||||
* XRAPI_CALL - Placed after the return type in function declarations.
|
||||
* Useful for MSVC-style calling convention syntax.
|
||||
* XRAPI_PTR - Placed between the '(' and '*' in function pointer types.
|
||||
*
|
||||
* Function declaration: XRAPI_ATTR void XRAPI_CALL xrFunction(void);
|
||||
* Function pointer type: typedef void (XRAPI_PTR *PFN_xrFunction)(void);
|
||||
*/
|
||||
#if defined(_WIN32)
|
||||
#define XRAPI_ATTR
|
||||
// On Windows, functions use the stdcall convention
|
||||
#define XRAPI_CALL __stdcall
|
||||
#define XRAPI_PTR XRAPI_CALL
|
||||
#elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH < 7
|
||||
#error "API not supported for the 'armeabi' NDK ABI"
|
||||
#elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH >= 7 && defined(__ARM_32BIT_STATE)
|
||||
// On Android 32-bit ARM targets, functions use the "hardfloat"
|
||||
// calling convention, i.e. float parameters are passed in registers. This
|
||||
// is true even if the rest of the application passes floats on the stack,
|
||||
// as it does by default when compiling for the armeabi-v7a NDK ABI.
|
||||
#define XRAPI_ATTR __attribute__((pcs("aapcs-vfp")))
|
||||
#define XRAPI_CALL
|
||||
#define XRAPI_PTR XRAPI_ATTR
|
||||
#else
|
||||
// On other platforms, use the default calling convention
|
||||
#define XRAPI_ATTR
|
||||
#define XRAPI_CALL
|
||||
#define XRAPI_PTR
|
||||
#endif
|
||||
|
||||
#include <stddef.h>
|
||||
|
||||
#if !defined(XR_NO_STDINT_H)
|
||||
#if defined(_MSC_VER) && (_MSC_VER < 1600)
|
||||
typedef signed __int8 int8_t;
|
||||
typedef unsigned __int8 uint8_t;
|
||||
typedef signed __int16 int16_t;
|
||||
typedef unsigned __int16 uint16_t;
|
||||
typedef signed __int32 int32_t;
|
||||
typedef unsigned __int32 uint32_t;
|
||||
typedef signed __int64 int64_t;
|
||||
typedef unsigned __int64 uint64_t;
|
||||
#else
|
||||
#include <stdint.h>
|
||||
#endif
|
||||
#endif // !defined( XR_NO_STDINT_H )
|
||||
|
||||
// XR_PTR_SIZE (in bytes)
|
||||
#if (defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined(_M_IA64) || defined(__aarch64__) || defined(__powerpc64__))
|
||||
#define XR_PTR_SIZE 8
|
||||
#else
|
||||
#define XR_PTR_SIZE 4
|
||||
#endif
|
||||
|
||||
// Needed so we can use clang __has_feature portably.
|
||||
#if !defined(XR_COMPILER_HAS_FEATURE)
|
||||
#if defined(__clang__)
|
||||
#define XR_COMPILER_HAS_FEATURE(x) __has_feature(x)
|
||||
#else
|
||||
#define XR_COMPILER_HAS_FEATURE(x) 0
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// Identifies if the current compiler has C++11 support enabled.
|
||||
// Does not by itself identify if any given C++11 feature is present.
|
||||
#if !defined(XR_CPP11_ENABLED) && defined(__cplusplus)
|
||||
#if defined(__GNUC__) && defined(__GXX_EXPERIMENTAL_CXX0X__)
|
||||
#define XR_CPP11_ENABLED 1
|
||||
#elif defined(_MSC_VER) && (_MSC_VER >= 1600)
|
||||
#define XR_CPP11_ENABLED 1
|
||||
#elif (__cplusplus >= 201103L) // 201103 is the first C++11 version.
|
||||
#define XR_CPP11_ENABLED 1
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// Identifies if the current compiler supports C++11 nullptr.
|
||||
#if !defined(XR_CPP_NULLPTR_SUPPORTED)
|
||||
#if defined(XR_CPP11_ENABLED) && \
|
||||
((defined(__clang__) && XR_COMPILER_HAS_FEATURE(cxx_nullptr)) || \
|
||||
(defined(__GNUC__) && (((__GNUC__ * 1000) + __GNUC_MINOR__) >= 4006)) || \
|
||||
(defined(_MSC_VER) && (_MSC_VER >= 1600)) || \
|
||||
(defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 403)))
|
||||
#define XR_CPP_NULLPTR_SUPPORTED 1
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if !defined(XR_CPP_NULLPTR_SUPPORTED)
|
||||
#define XR_CPP_NULLPTR_SUPPORTED 0
|
||||
#endif // !defined(XR_CPP_NULLPTR_SUPPORTED)
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
Reference in new issue
Block a user