From 71da6a929374125ba436137f6b9cad178ed5cf9b Mon Sep 17 00:00:00 2001 From: Lubos Date: Wed, 6 Jul 2022 21:38:41 +0200 Subject: [PATCH 01/30] OpenXR - Quest target into Android Studio project added --- CMakeLists.txt | 5 + Common/GPU/Vulkan/VulkanLoader.cpp | 6 ++ quest/.gitignore | 10 ++ quest/AndroidManifest.xml | 123 +++++++++++++++++++++ quest/build.gradle | 166 +++++++++++++++++++++++++++++ quest/gradle.properties | 3 + quest/proguard-project.txt | 20 ++++ quest/project.properties | 12 +++ settings.gradle | 2 +- 9 files changed, 346 insertions(+), 1 deletion(-) create mode 100644 quest/.gitignore create mode 100644 quest/AndroidManifest.xml create mode 100644 quest/build.gradle create mode 100644 quest/gradle.properties create mode 100644 quest/proguard-project.txt create mode 100644 quest/project.properties diff --git a/CMakeLists.txt b/CMakeLists.txt index 22b4b802c318..71d4a769d830 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -116,6 +116,11 @@ include(GNUInstallDirs) add_definitions(-DASSETS_DIR="${CMAKE_INSTALL_FULL_DATADIR}/ppsspp/assets/") +if(OPENXR) + add_definitions(-DOPENXR) + message("OpenXR enabled") +endif() + if(GOLD) add_definitions(-DGOLD) message("Gold Build") diff --git a/Common/GPU/Vulkan/VulkanLoader.cpp b/Common/GPU/Vulkan/VulkanLoader.cpp index 7037d5889ed8..4f46051a6f5b 100644 --- a/Common/GPU/Vulkan/VulkanLoader.cpp +++ b/Common/GPU/Vulkan/VulkanLoader.cpp @@ -305,6 +305,12 @@ void VulkanSetAvailable(bool available) { } bool VulkanMayBeAvailable() { + +#ifdef OPENXR + //unsupported at the moment + return false; +#endif + if (g_vulkanAvailabilityChecked) { return g_vulkanMayBeAvailable; } diff --git a/quest/.gitignore b/quest/.gitignore new file mode 100644 index 000000000000..56dc5a93532f --- /dev/null +++ b/quest/.gitignore @@ -0,0 +1,10 @@ +bin +gen +libs +obj +build*/ +gen +obj +.cxx +.externalNativeBuild +android.iml diff --git a/quest/AndroidManifest.xml b/quest/AndroidManifest.xml new file mode 100644 index 000000000000..2ae4d17046c1 --- /dev/null +++ b/quest/AndroidManifest.xml @@ -0,0 +1,123 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/quest/build.gradle b/quest/build.gradle new file mode 100644 index 000000000000..36f51d66c683 --- /dev/null +++ b/quest/build.gradle @@ -0,0 +1,166 @@ +plugins { + id 'com.gladed.androidgitversion' version '0.4.5' +} +apply plugin: 'com.android.application' + +androidGitVersion { + codeFormat = "MNNPPBBBB" + format = "%tag%%-count%%-branch%%-dirty%" + prefix = "v" // Only tags beginning with v are considered. + untrackedIsDirty = false +} + +dependencies { + def appcompat_version = "1.2.0" + + implementation "androidx.appcompat:appcompat:$appcompat_version" + + // Convenient wrapper around DocumentContract. Might look into writing our own + // to see if there's some performance to squeeze at some point, but doubt it. + implementation "androidx.documentfile:documentfile:1.0.1" +} + +android { + flavorDimensions "variant" + + signingConfigs { + debug { + storeFile file("../android/debug.keystore") + } + optimized { + storeFile file("../android/debug.keystore") + } + + // Set these in a system global (or project local, but not checked in) gradle.properties . + if (project.hasProperty("RELEASE_STORE_FILE")) { + release { + storeFile file(RELEASE_STORE_FILE) + storePassword RELEASE_STORE_PASSWORD + keyAlias RELEASE_KEY_ALIAS + keyPassword RELEASE_KEY_PASSWORD + } + } else { + release { + } + } + } + compileSdkVersion 32 + defaultConfig { + applicationId 'org.ppsspp.ppsspp' + if (androidGitVersion.name() != "unknown" && androidGitVersion.code() >= 14000000) { + // Start using automatic Android version numbers from version 1.4. + println "Overriding Android Version Name, Code: " + androidGitVersion.name() + " " + androidGitVersion.code(); + versionName androidGitVersion.name() + versionCode androidGitVersion.code() + } else { + println "(not using these:) Android Version Name, Code: " + androidGitVersion.name() + " " + androidGitVersion.code(); + } + + new File("versionname.txt").write(androidGitVersion.name()) + new File("versioncode.txt").write(androidGitVersion.code().toString()) + + minSdkVersion 9 + targetSdkVersion 32 + if (project.hasProperty("ANDROID_VERSION_CODE") && project.hasProperty("ANDROID_VERSION_NAME")) { + versionCode ANDROID_VERSION_CODE + versionName ANDROID_VERSION_NAME + } + ndk { + abiFilters 'armeabi-v7a', 'arm64-v8a', 'x86', 'x86_64' + } + signingConfig signingConfigs.debug + } + buildTypes { + debug { + minifyEnabled = false + jniDebuggable true + signingConfig signingConfigs.debug + } + optimized { + // Debug signed but optimized. + minifyEnabled = false + jniDebuggable true + signingConfig android.buildTypes.debug.signingConfig + } + release { + minifyEnabled = false + signingConfig signingConfigs.release + } + } + externalNativeBuild { + cmake { + path '../CMakeLists.txt' + } + } + sourceSets { + main { + manifest.srcFile 'AndroidManifest.xml' + res.srcDirs = ['../android/res'] + java.srcDirs = ['../android/src'] + aidl.srcDirs = ['../android/src'] + resources.srcDirs = ['../android/src'] + assets.srcDirs = [ + '../assets', + ] + } + gold { + res.srcDirs = ['../android/gold/res'] + } + } + productFlavors { + normal { + applicationId 'org.ppsspp.ppsspp' + dimension "variant" + externalNativeBuild { + cmake { + // Available arguments listed at https://developer.android.com/ndk/guides/cmake.html + arguments '-DANDROID=true', + '-DANDROID_PLATFORM=android-16', + '-DANDROID_TOOLCHAIN=clang', + '-DANDROID_CPP_FEATURES=', + '-DANDROID_STL=c++_static', + '-DANDROID_ARM_NEON=TRUE', + '-DOPENXR=TRUE' + } + } + } + gold { + applicationId 'org.ppsspp.ppssppgold' + dimension "variant" + externalNativeBuild { + cmake { + // Available arguments listed at https://developer.android.com/ndk/guides/cmake.html + arguments '-DANDROID=true', + '-DANDROID_PLATFORM=android-16', + '-DANDROID_TOOLCHAIN=clang', + '-DANDROID_CPP_FEATURES=', + '-DANDROID_STL=c++_static', + '-DANDROID_ARM_NEON=TRUE', + '-DOPENXR=TRUE', + '-DGOLD=TRUE' + } + } + } + } + variantFilter { variant -> + def needed = variant.name in [ + 'normalDebug', // for debugging + 'normalOptimized', // for testing + 'normalRelease', // for Google Play releases + 'goldRelease' // for Google Play releases + ] + variant.setIgnore(!needed) + } +} +afterEvaluate { + android.sourceSets.main.assets.getSrcDirs().each { println it } +} + +// F-Droid lite version can be created with : ./gradlew assembleOptimized -Pf_droid +if (project.hasProperty("f_droid")) { + project.android.sourceSets.main.java.srcDirs += '../android/libs/MogaStubs' +} else { + project.dependencies { + implementation files('../android/libs/com.bda.controller.jar') + } +} diff --git a/quest/gradle.properties b/quest/gradle.properties new file mode 100644 index 000000000000..4d3226abc21b --- /dev/null +++ b/quest/gradle.properties @@ -0,0 +1,3 @@ +org.gradle.jvmargs=-Xmx1536M +android.useAndroidX=true +android.enableJetifier=true \ No newline at end of file diff --git a/quest/proguard-project.txt b/quest/proguard-project.txt new file mode 100644 index 000000000000..f2fe1559a217 --- /dev/null +++ b/quest/proguard-project.txt @@ -0,0 +1,20 @@ +# To enable ProGuard in your project, edit project.properties +# to define the proguard.config property as described in that file. +# +# Add project specific ProGuard rules here. +# By default, the flags in this file are appended to flags specified +# in ${sdk.dir}/tools/proguard/proguard-android.txt +# You can edit the include path and order by changing the ProGuard +# include property in project.properties. +# +# For more details, see +# http://developer.android.com/guide/developing/tools/proguard.html + +# Add any project specific keep options here: + +# If your project uses WebView with JS, uncomment the following +# and specify the fully qualified class name to the JavaScript interface +# class: +#-keepclassmembers class fqcn.of.javascript.interface.for.webview { +# public *; +#} diff --git a/quest/project.properties b/quest/project.properties new file mode 100644 index 000000000000..5e19b7a0b16e --- /dev/null +++ b/quest/project.properties @@ -0,0 +1,12 @@ +# This file is automatically generated by Android Tools. +# Do not modify this file -- YOUR CHANGES WILL BE ERASED! +# +# This file must be checked in Version Control Systems. +# +# To customize properties used by the Ant build system edit +# "ant.properties", and override values to adapt the script to your +# project structure. +# + +# Project target. +target=android-26 diff --git a/settings.gradle b/settings.gradle index d69713c24522..8d6e2032bcfb 100644 --- a/settings.gradle +++ b/settings.gradle @@ -1 +1 @@ -include ':android' +include ':android',':quest' From 99a4a06286f67d9304b3db37b04de8823296407d Mon Sep 17 00:00:00 2001 From: Lubos Date: Thu, 7 Jul 2022 17:39:17 +0200 Subject: [PATCH 02/30] OpenXR - SDK added --- CMakeLists.txt | 2 + ext/openxr/openxr.h | 3925 ++++++++++++++++++++++ ext/openxr/openxr_platform.h | 675 ++++ ext/openxr/openxr_platform_defines.h | 110 + ext/openxr/openxr_reflection.h | 2744 +++++++++++++++ quest/.gitignore | 1 - quest/build.gradle | 9 +- quest/libs/arm64-v8a/libopenxr_loader.so | Bin 0 -> 8250944 bytes 8 files changed, 7460 insertions(+), 6 deletions(-) create mode 100755 ext/openxr/openxr.h create mode 100755 ext/openxr/openxr_platform.h create mode 100755 ext/openxr/openxr_platform_defines.h create mode 100755 ext/openxr/openxr_reflection.h create mode 100755 quest/libs/arm64-v8a/libopenxr_loader.so diff --git a/CMakeLists.txt b/CMakeLists.txt index 71d4a769d830..c9e47538c5f7 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -118,6 +118,8 @@ add_definitions(-DASSETS_DIR="${CMAKE_INSTALL_FULL_DATADIR}/ppsspp/assets/") if(OPENXR) add_definitions(-DOPENXR) + include_directories(ext/openxr) + link_directories(quest/libs/arm64-v8a) message("OpenXR enabled") endif() diff --git a/ext/openxr/openxr.h b/ext/openxr/openxr.h new file mode 100755 index 000000000000..8798e5a6e022 --- /dev/null +++ b/ext/openxr/openxr.h @@ -0,0 +1,3925 @@ +#ifndef OPENXR_H_ +#define OPENXR_H_ 1 + +/* +** Copyright (c) 2017-2022, The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 OR MIT +*/ + +/* +** This header is generated from the Khronos OpenXR XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +#define XR_VERSION_1_0 1 +#include "openxr_platform_defines.h" +#define XR_MAKE_VERSION(major, minor, patch) \ + ((((major) & 0xffffULL) << 48) | (((minor) & 0xffffULL) << 32) | ((patch) & 0xffffffffULL)) + +// OpenXR current version number. +#define XR_CURRENT_API_VERSION XR_MAKE_VERSION(1, 0, 22) + +#define XR_VERSION_MAJOR(version) (uint16_t)(((uint64_t)(version) >> 48)& 0xffffULL) +#define XR_VERSION_MINOR(version) (uint16_t)(((uint64_t)(version) >> 32) & 0xffffULL) +#define XR_VERSION_PATCH(version) (uint32_t)((uint64_t)(version) & 0xffffffffULL) + +#if !defined(XR_NULL_HANDLE) +#if (XR_PTR_SIZE == 8) && XR_CPP_NULLPTR_SUPPORTED + #define XR_NULL_HANDLE nullptr +#else + #define XR_NULL_HANDLE 0 +#endif +#endif + + + +#define XR_NULL_SYSTEM_ID 0 + + +#define XR_NULL_PATH 0 + + +#define XR_SUCCEEDED(result) ((result) >= 0) + + +#define XR_FAILED(result) ((result) < 0) + + +#define XR_UNQUALIFIED_SUCCESS(result) ((result) == 0) + + +#define XR_NO_DURATION 0 + + +#define XR_INFINITE_DURATION 0x7fffffffffffffffLL + + +#define XR_MIN_HAPTIC_DURATION -1 + + +#define XR_FREQUENCY_UNSPECIFIED 0 + + +#define XR_MAX_EVENT_DATA_SIZE sizeof(XrEventDataBuffer) + + +#if !defined(XR_MAY_ALIAS) +#if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4)) +#define XR_MAY_ALIAS __attribute__((__may_alias__)) +#else +#define XR_MAY_ALIAS +#endif +#endif + + +#if !defined(XR_DEFINE_HANDLE) +#if (XR_PTR_SIZE == 8) + #define XR_DEFINE_HANDLE(object) typedef struct object##_T* object; +#else + #define XR_DEFINE_HANDLE(object) typedef uint64_t object; +#endif +#endif + + + +#if !defined(XR_DEFINE_ATOM) + #define XR_DEFINE_ATOM(object) typedef uint64_t object; +#endif + + +typedef uint64_t XrVersion; +typedef uint64_t XrFlags64; +XR_DEFINE_ATOM(XrSystemId) +typedef uint32_t XrBool32; +XR_DEFINE_ATOM(XrPath) +typedef int64_t XrTime; +typedef int64_t XrDuration; +XR_DEFINE_HANDLE(XrInstance) +XR_DEFINE_HANDLE(XrSession) +XR_DEFINE_HANDLE(XrSpace) +XR_DEFINE_HANDLE(XrAction) +XR_DEFINE_HANDLE(XrSwapchain) +XR_DEFINE_HANDLE(XrActionSet) +#define XR_TRUE 1 +#define XR_FALSE 0 +#define XR_MAX_EXTENSION_NAME_SIZE 128 +#define XR_MAX_API_LAYER_NAME_SIZE 256 +#define XR_MAX_API_LAYER_DESCRIPTION_SIZE 256 +#define XR_MAX_SYSTEM_NAME_SIZE 256 +#define XR_MAX_APPLICATION_NAME_SIZE 128 +#define XR_MAX_ENGINE_NAME_SIZE 128 +#define XR_MAX_RUNTIME_NAME_SIZE 128 +#define XR_MAX_PATH_LENGTH 256 +#define XR_MAX_STRUCTURE_NAME_SIZE 64 +#define XR_MAX_RESULT_STRING_SIZE 64 +#define XR_MIN_COMPOSITION_LAYERS_SUPPORTED 16 +#define XR_MAX_ACTION_SET_NAME_SIZE 64 +#define XR_MAX_LOCALIZED_ACTION_SET_NAME_SIZE 128 +#define XR_MAX_ACTION_NAME_SIZE 64 +#define XR_MAX_LOCALIZED_ACTION_NAME_SIZE 128 + +typedef enum XrResult { + XR_SUCCESS = 0, + XR_TIMEOUT_EXPIRED = 1, + XR_SESSION_LOSS_PENDING = 3, + XR_EVENT_UNAVAILABLE = 4, + XR_SPACE_BOUNDS_UNAVAILABLE = 7, + XR_SESSION_NOT_FOCUSED = 8, + XR_FRAME_DISCARDED = 9, + XR_ERROR_VALIDATION_FAILURE = -1, + XR_ERROR_RUNTIME_FAILURE = -2, + XR_ERROR_OUT_OF_MEMORY = -3, + XR_ERROR_API_VERSION_UNSUPPORTED = -4, + XR_ERROR_INITIALIZATION_FAILED = -6, + XR_ERROR_FUNCTION_UNSUPPORTED = -7, + XR_ERROR_FEATURE_UNSUPPORTED = -8, + XR_ERROR_EXTENSION_NOT_PRESENT = -9, + XR_ERROR_LIMIT_REACHED = -10, + XR_ERROR_SIZE_INSUFFICIENT = -11, + XR_ERROR_HANDLE_INVALID = -12, + XR_ERROR_INSTANCE_LOST = -13, + XR_ERROR_SESSION_RUNNING = -14, + XR_ERROR_SESSION_NOT_RUNNING = -16, + XR_ERROR_SESSION_LOST = -17, + XR_ERROR_SYSTEM_INVALID = -18, + XR_ERROR_PATH_INVALID = -19, + XR_ERROR_PATH_COUNT_EXCEEDED = -20, + XR_ERROR_PATH_FORMAT_INVALID = -21, + XR_ERROR_PATH_UNSUPPORTED = -22, + XR_ERROR_LAYER_INVALID = -23, + XR_ERROR_LAYER_LIMIT_EXCEEDED = -24, + XR_ERROR_SWAPCHAIN_RECT_INVALID = -25, + XR_ERROR_SWAPCHAIN_FORMAT_UNSUPPORTED = -26, + XR_ERROR_ACTION_TYPE_MISMATCH = -27, + XR_ERROR_SESSION_NOT_READY = -28, + XR_ERROR_SESSION_NOT_STOPPING = -29, + XR_ERROR_TIME_INVALID = -30, + XR_ERROR_REFERENCE_SPACE_UNSUPPORTED = -31, + XR_ERROR_FILE_ACCESS_ERROR = -32, + XR_ERROR_FILE_CONTENTS_INVALID = -33, + XR_ERROR_FORM_FACTOR_UNSUPPORTED = -34, + XR_ERROR_FORM_FACTOR_UNAVAILABLE = -35, + XR_ERROR_API_LAYER_NOT_PRESENT = -36, + XR_ERROR_CALL_ORDER_INVALID = -37, + XR_ERROR_GRAPHICS_DEVICE_INVALID = -38, + XR_ERROR_POSE_INVALID = -39, + XR_ERROR_INDEX_OUT_OF_RANGE = -40, + XR_ERROR_VIEW_CONFIGURATION_TYPE_UNSUPPORTED = -41, + XR_ERROR_ENVIRONMENT_BLEND_MODE_UNSUPPORTED = -42, + XR_ERROR_NAME_DUPLICATED = -44, + XR_ERROR_NAME_INVALID = -45, + XR_ERROR_ACTIONSET_NOT_ATTACHED = -46, + XR_ERROR_ACTIONSETS_ALREADY_ATTACHED = -47, + XR_ERROR_LOCALIZED_NAME_DUPLICATED = -48, + XR_ERROR_LOCALIZED_NAME_INVALID = -49, + XR_ERROR_GRAPHICS_REQUIREMENTS_CALL_MISSING = -50, + XR_ERROR_RUNTIME_UNAVAILABLE = -51, + XR_ERROR_ANDROID_THREAD_SETTINGS_ID_INVALID_KHR = -1000003000, + XR_ERROR_ANDROID_THREAD_SETTINGS_FAILURE_KHR = -1000003001, + XR_ERROR_CREATE_SPATIAL_ANCHOR_FAILED_MSFT = -1000039001, + XR_ERROR_SECONDARY_VIEW_CONFIGURATION_TYPE_NOT_ENABLED_MSFT = -1000053000, + XR_ERROR_CONTROLLER_MODEL_KEY_INVALID_MSFT = -1000055000, + XR_ERROR_REPROJECTION_MODE_UNSUPPORTED_MSFT = -1000066000, + XR_ERROR_COMPUTE_NEW_SCENE_NOT_COMPLETED_MSFT = -1000097000, + XR_ERROR_SCENE_COMPONENT_ID_INVALID_MSFT = -1000097001, + XR_ERROR_SCENE_COMPONENT_TYPE_MISMATCH_MSFT = -1000097002, + XR_ERROR_SCENE_MESH_BUFFER_ID_INVALID_MSFT = -1000097003, + XR_ERROR_SCENE_COMPUTE_FEATURE_INCOMPATIBLE_MSFT = -1000097004, + XR_ERROR_SCENE_COMPUTE_CONSISTENCY_MISMATCH_MSFT = -1000097005, + XR_ERROR_DISPLAY_REFRESH_RATE_UNSUPPORTED_FB = -1000101000, + XR_ERROR_COLOR_SPACE_UNSUPPORTED_FB = -1000108000, + XR_ERROR_UNEXPECTED_STATE_PASSTHROUGH_FB = -1000118000, + XR_ERROR_FEATURE_ALREADY_CREATED_PASSTHROUGH_FB = -1000118001, + XR_ERROR_FEATURE_REQUIRED_PASSTHROUGH_FB = -1000118002, + XR_ERROR_NOT_PERMITTED_PASSTHROUGH_FB = -1000118003, + XR_ERROR_INSUFFICIENT_RESOURCES_PASSTHROUGH_FB = -1000118004, + XR_ERROR_UNKNOWN_PASSTHROUGH_FB = -1000118050, + XR_ERROR_RENDER_MODEL_KEY_INVALID_FB = -1000119000, + XR_RENDER_MODEL_UNAVAILABLE_FB = 1000119020, + XR_ERROR_MARKER_NOT_TRACKED_VARJO = -1000124000, + XR_ERROR_MARKER_ID_INVALID_VARJO = -1000124001, + XR_ERROR_SPATIAL_ANCHOR_NAME_NOT_FOUND_MSFT = -1000142001, + XR_ERROR_SPATIAL_ANCHOR_NAME_INVALID_MSFT = -1000142002, + XR_RESULT_MAX_ENUM = 0x7FFFFFFF +} XrResult; + +typedef enum XrStructureType { + XR_TYPE_UNKNOWN = 0, + XR_TYPE_API_LAYER_PROPERTIES = 1, + XR_TYPE_EXTENSION_PROPERTIES = 2, + XR_TYPE_INSTANCE_CREATE_INFO = 3, + XR_TYPE_SYSTEM_GET_INFO = 4, + XR_TYPE_SYSTEM_PROPERTIES = 5, + XR_TYPE_VIEW_LOCATE_INFO = 6, + XR_TYPE_VIEW = 7, + XR_TYPE_SESSION_CREATE_INFO = 8, + XR_TYPE_SWAPCHAIN_CREATE_INFO = 9, + XR_TYPE_SESSION_BEGIN_INFO = 10, + XR_TYPE_VIEW_STATE = 11, + XR_TYPE_FRAME_END_INFO = 12, + XR_TYPE_HAPTIC_VIBRATION = 13, + XR_TYPE_EVENT_DATA_BUFFER = 16, + XR_TYPE_EVENT_DATA_INSTANCE_LOSS_PENDING = 17, + XR_TYPE_EVENT_DATA_SESSION_STATE_CHANGED = 18, + XR_TYPE_ACTION_STATE_BOOLEAN = 23, + XR_TYPE_ACTION_STATE_FLOAT = 24, + XR_TYPE_ACTION_STATE_VECTOR2F = 25, + XR_TYPE_ACTION_STATE_POSE = 27, + XR_TYPE_ACTION_SET_CREATE_INFO = 28, + XR_TYPE_ACTION_CREATE_INFO = 29, + XR_TYPE_INSTANCE_PROPERTIES = 32, + XR_TYPE_FRAME_WAIT_INFO = 33, + XR_TYPE_COMPOSITION_LAYER_PROJECTION = 35, + XR_TYPE_COMPOSITION_LAYER_QUAD = 36, + XR_TYPE_REFERENCE_SPACE_CREATE_INFO = 37, + XR_TYPE_ACTION_SPACE_CREATE_INFO = 38, + XR_TYPE_EVENT_DATA_REFERENCE_SPACE_CHANGE_PENDING = 40, + XR_TYPE_VIEW_CONFIGURATION_VIEW = 41, + XR_TYPE_SPACE_LOCATION = 42, + XR_TYPE_SPACE_VELOCITY = 43, + XR_TYPE_FRAME_STATE = 44, + XR_TYPE_VIEW_CONFIGURATION_PROPERTIES = 45, + XR_TYPE_FRAME_BEGIN_INFO = 46, + XR_TYPE_COMPOSITION_LAYER_PROJECTION_VIEW = 48, + XR_TYPE_EVENT_DATA_EVENTS_LOST = 49, + XR_TYPE_INTERACTION_PROFILE_SUGGESTED_BINDING = 51, + XR_TYPE_EVENT_DATA_INTERACTION_PROFILE_CHANGED = 52, + XR_TYPE_INTERACTION_PROFILE_STATE = 53, + XR_TYPE_SWAPCHAIN_IMAGE_ACQUIRE_INFO = 55, + XR_TYPE_SWAPCHAIN_IMAGE_WAIT_INFO = 56, + XR_TYPE_SWAPCHAIN_IMAGE_RELEASE_INFO = 57, + XR_TYPE_ACTION_STATE_GET_INFO = 58, + XR_TYPE_HAPTIC_ACTION_INFO = 59, + XR_TYPE_SESSION_ACTION_SETS_ATTACH_INFO = 60, + XR_TYPE_ACTIONS_SYNC_INFO = 61, + XR_TYPE_BOUND_SOURCES_FOR_ACTION_ENUMERATE_INFO = 62, + XR_TYPE_INPUT_SOURCE_LOCALIZED_NAME_GET_INFO = 63, + XR_TYPE_COMPOSITION_LAYER_CUBE_KHR = 1000006000, + XR_TYPE_INSTANCE_CREATE_INFO_ANDROID_KHR = 1000008000, + XR_TYPE_COMPOSITION_LAYER_DEPTH_INFO_KHR = 1000010000, + XR_TYPE_VULKAN_SWAPCHAIN_FORMAT_LIST_CREATE_INFO_KHR = 1000014000, + XR_TYPE_EVENT_DATA_PERF_SETTINGS_EXT = 1000015000, + XR_TYPE_COMPOSITION_LAYER_CYLINDER_KHR = 1000017000, + XR_TYPE_COMPOSITION_LAYER_EQUIRECT_KHR = 1000018000, + XR_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT = 1000019000, + XR_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT = 1000019001, + XR_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT = 1000019002, + XR_TYPE_DEBUG_UTILS_LABEL_EXT = 1000019003, + XR_TYPE_GRAPHICS_BINDING_OPENGL_WIN32_KHR = 1000023000, + XR_TYPE_GRAPHICS_BINDING_OPENGL_XLIB_KHR = 1000023001, + XR_TYPE_GRAPHICS_BINDING_OPENGL_XCB_KHR = 1000023002, + XR_TYPE_GRAPHICS_BINDING_OPENGL_WAYLAND_KHR = 1000023003, + XR_TYPE_SWAPCHAIN_IMAGE_OPENGL_KHR = 1000023004, + XR_TYPE_GRAPHICS_REQUIREMENTS_OPENGL_KHR = 1000023005, + XR_TYPE_GRAPHICS_BINDING_OPENGL_ES_ANDROID_KHR = 1000024001, + XR_TYPE_SWAPCHAIN_IMAGE_OPENGL_ES_KHR = 1000024002, + XR_TYPE_GRAPHICS_REQUIREMENTS_OPENGL_ES_KHR = 1000024003, + XR_TYPE_GRAPHICS_BINDING_VULKAN_KHR = 1000025000, + XR_TYPE_SWAPCHAIN_IMAGE_VULKAN_KHR = 1000025001, + XR_TYPE_GRAPHICS_REQUIREMENTS_VULKAN_KHR = 1000025002, + XR_TYPE_GRAPHICS_BINDING_D3D11_KHR = 1000027000, + XR_TYPE_SWAPCHAIN_IMAGE_D3D11_KHR = 1000027001, + XR_TYPE_GRAPHICS_REQUIREMENTS_D3D11_KHR = 1000027002, + XR_TYPE_GRAPHICS_BINDING_D3D12_KHR = 1000028000, + XR_TYPE_SWAPCHAIN_IMAGE_D3D12_KHR = 1000028001, + XR_TYPE_GRAPHICS_REQUIREMENTS_D3D12_KHR = 1000028002, + XR_TYPE_SYSTEM_EYE_GAZE_INTERACTION_PROPERTIES_EXT = 1000030000, + XR_TYPE_EYE_GAZE_SAMPLE_TIME_EXT = 1000030001, + XR_TYPE_VISIBILITY_MASK_KHR = 1000031000, + XR_TYPE_EVENT_DATA_VISIBILITY_MASK_CHANGED_KHR = 1000031001, + XR_TYPE_SESSION_CREATE_INFO_OVERLAY_EXTX = 1000033000, + XR_TYPE_EVENT_DATA_MAIN_SESSION_VISIBILITY_CHANGED_EXTX = 1000033003, + XR_TYPE_COMPOSITION_LAYER_COLOR_SCALE_BIAS_KHR = 1000034000, + XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_MSFT = 1000039000, + XR_TYPE_SPATIAL_ANCHOR_SPACE_CREATE_INFO_MSFT = 1000039001, + XR_TYPE_COMPOSITION_LAYER_IMAGE_LAYOUT_FB = 1000040000, + XR_TYPE_COMPOSITION_LAYER_ALPHA_BLEND_FB = 1000041001, + XR_TYPE_VIEW_CONFIGURATION_DEPTH_RANGE_EXT = 1000046000, + XR_TYPE_GRAPHICS_BINDING_EGL_MNDX = 1000048004, + XR_TYPE_SPATIAL_GRAPH_NODE_SPACE_CREATE_INFO_MSFT = 1000049000, + XR_TYPE_SYSTEM_HAND_TRACKING_PROPERTIES_EXT = 1000051000, + XR_TYPE_HAND_TRACKER_CREATE_INFO_EXT = 1000051001, + XR_TYPE_HAND_JOINTS_LOCATE_INFO_EXT = 1000051002, + XR_TYPE_HAND_JOINT_LOCATIONS_EXT = 1000051003, + XR_TYPE_HAND_JOINT_VELOCITIES_EXT = 1000051004, + XR_TYPE_SYSTEM_HAND_TRACKING_MESH_PROPERTIES_MSFT = 1000052000, + XR_TYPE_HAND_MESH_SPACE_CREATE_INFO_MSFT = 1000052001, + XR_TYPE_HAND_MESH_UPDATE_INFO_MSFT = 1000052002, + XR_TYPE_HAND_MESH_MSFT = 1000052003, + XR_TYPE_HAND_POSE_TYPE_INFO_MSFT = 1000052004, + XR_TYPE_SECONDARY_VIEW_CONFIGURATION_SESSION_BEGIN_INFO_MSFT = 1000053000, + XR_TYPE_SECONDARY_VIEW_CONFIGURATION_STATE_MSFT = 1000053001, + XR_TYPE_SECONDARY_VIEW_CONFIGURATION_FRAME_STATE_MSFT = 1000053002, + XR_TYPE_SECONDARY_VIEW_CONFIGURATION_FRAME_END_INFO_MSFT = 1000053003, + XR_TYPE_SECONDARY_VIEW_CONFIGURATION_LAYER_INFO_MSFT = 1000053004, + XR_TYPE_SECONDARY_VIEW_CONFIGURATION_SWAPCHAIN_CREATE_INFO_MSFT = 1000053005, + XR_TYPE_CONTROLLER_MODEL_KEY_STATE_MSFT = 1000055000, + XR_TYPE_CONTROLLER_MODEL_NODE_PROPERTIES_MSFT = 1000055001, + XR_TYPE_CONTROLLER_MODEL_PROPERTIES_MSFT = 1000055002, + XR_TYPE_CONTROLLER_MODEL_NODE_STATE_MSFT = 1000055003, + XR_TYPE_CONTROLLER_MODEL_STATE_MSFT = 1000055004, + XR_TYPE_VIEW_CONFIGURATION_VIEW_FOV_EPIC = 1000059000, + XR_TYPE_HOLOGRAPHIC_WINDOW_ATTACHMENT_MSFT = 1000063000, + XR_TYPE_COMPOSITION_LAYER_REPROJECTION_INFO_MSFT = 1000066000, + XR_TYPE_COMPOSITION_LAYER_REPROJECTION_PLANE_OVERRIDE_MSFT = 1000066001, + XR_TYPE_ANDROID_SURFACE_SWAPCHAIN_CREATE_INFO_FB = 1000070000, + XR_TYPE_COMPOSITION_LAYER_SECURE_CONTENT_FB = 1000072000, + XR_TYPE_INTERACTION_PROFILE_ANALOG_THRESHOLD_VALVE = 1000079000, + XR_TYPE_HAND_JOINTS_MOTION_RANGE_INFO_EXT = 1000080000, + XR_TYPE_LOADER_INIT_INFO_ANDROID_KHR = 1000089000, + XR_TYPE_VULKAN_INSTANCE_CREATE_INFO_KHR = 1000090000, + XR_TYPE_VULKAN_DEVICE_CREATE_INFO_KHR = 1000090001, + XR_TYPE_VULKAN_GRAPHICS_DEVICE_GET_INFO_KHR = 1000090003, + XR_TYPE_COMPOSITION_LAYER_EQUIRECT2_KHR = 1000091000, + XR_TYPE_SCENE_OBSERVER_CREATE_INFO_MSFT = 1000097000, + XR_TYPE_SCENE_CREATE_INFO_MSFT = 1000097001, + XR_TYPE_NEW_SCENE_COMPUTE_INFO_MSFT = 1000097002, + XR_TYPE_VISUAL_MESH_COMPUTE_LOD_INFO_MSFT = 1000097003, + XR_TYPE_SCENE_COMPONENTS_MSFT = 1000097004, + XR_TYPE_SCENE_COMPONENTS_GET_INFO_MSFT = 1000097005, + XR_TYPE_SCENE_COMPONENT_LOCATIONS_MSFT = 1000097006, + XR_TYPE_SCENE_COMPONENTS_LOCATE_INFO_MSFT = 1000097007, + XR_TYPE_SCENE_OBJECTS_MSFT = 1000097008, + XR_TYPE_SCENE_COMPONENT_PARENT_FILTER_INFO_MSFT = 1000097009, + XR_TYPE_SCENE_OBJECT_TYPES_FILTER_INFO_MSFT = 1000097010, + XR_TYPE_SCENE_PLANES_MSFT = 1000097011, + XR_TYPE_SCENE_PLANE_ALIGNMENT_FILTER_INFO_MSFT = 1000097012, + XR_TYPE_SCENE_MESHES_MSFT = 1000097013, + XR_TYPE_SCENE_MESH_BUFFERS_GET_INFO_MSFT = 1000097014, + XR_TYPE_SCENE_MESH_BUFFERS_MSFT = 1000097015, + XR_TYPE_SCENE_MESH_VERTEX_BUFFER_MSFT = 1000097016, + XR_TYPE_SCENE_MESH_INDICES_UINT32_MSFT = 1000097017, + XR_TYPE_SCENE_MESH_INDICES_UINT16_MSFT = 1000097018, + XR_TYPE_SERIALIZED_SCENE_FRAGMENT_DATA_GET_INFO_MSFT = 1000098000, + XR_TYPE_SCENE_DESERIALIZE_INFO_MSFT = 1000098001, + XR_TYPE_EVENT_DATA_DISPLAY_REFRESH_RATE_CHANGED_FB = 1000101000, + XR_TYPE_VIVE_TRACKER_PATHS_HTCX = 1000103000, + XR_TYPE_EVENT_DATA_VIVE_TRACKER_CONNECTED_HTCX = 1000103001, + XR_TYPE_SYSTEM_FACIAL_TRACKING_PROPERTIES_HTC = 1000104000, + XR_TYPE_FACIAL_TRACKER_CREATE_INFO_HTC = 1000104001, + XR_TYPE_FACIAL_EXPRESSIONS_HTC = 1000104002, + XR_TYPE_SYSTEM_COLOR_SPACE_PROPERTIES_FB = 1000108000, + XR_TYPE_HAND_TRACKING_MESH_FB = 1000110001, + XR_TYPE_HAND_TRACKING_SCALE_FB = 1000110003, + XR_TYPE_HAND_TRACKING_AIM_STATE_FB = 1000111001, + XR_TYPE_HAND_TRACKING_CAPSULES_STATE_FB = 1000112000, + XR_TYPE_FOVEATION_PROFILE_CREATE_INFO_FB = 1000114000, + XR_TYPE_SWAPCHAIN_CREATE_INFO_FOVEATION_FB = 1000114001, + XR_TYPE_SWAPCHAIN_STATE_FOVEATION_FB = 1000114002, + XR_TYPE_FOVEATION_LEVEL_PROFILE_CREATE_INFO_FB = 1000115000, + XR_TYPE_KEYBOARD_SPACE_CREATE_INFO_FB = 1000116009, + XR_TYPE_KEYBOARD_TRACKING_QUERY_FB = 1000116004, + XR_TYPE_SYSTEM_KEYBOARD_TRACKING_PROPERTIES_FB = 1000116002, + XR_TYPE_TRIANGLE_MESH_CREATE_INFO_FB = 1000117001, + XR_TYPE_SYSTEM_PASSTHROUGH_PROPERTIES_FB = 1000118000, + XR_TYPE_PASSTHROUGH_CREATE_INFO_FB = 1000118001, + XR_TYPE_PASSTHROUGH_LAYER_CREATE_INFO_FB = 1000118002, + XR_TYPE_COMPOSITION_LAYER_PASSTHROUGH_FB = 1000118003, + XR_TYPE_GEOMETRY_INSTANCE_CREATE_INFO_FB = 1000118004, + XR_TYPE_GEOMETRY_INSTANCE_TRANSFORM_FB = 1000118005, + XR_TYPE_PASSTHROUGH_STYLE_FB = 1000118020, + XR_TYPE_PASSTHROUGH_COLOR_MAP_MONO_TO_RGBA_FB = 1000118021, + XR_TYPE_PASSTHROUGH_COLOR_MAP_MONO_TO_MONO_FB = 1000118022, + XR_TYPE_EVENT_DATA_PASSTHROUGH_STATE_CHANGED_FB = 1000118030, + XR_TYPE_RENDER_MODEL_PATH_INFO_FB = 1000119000, + XR_TYPE_RENDER_MODEL_PROPERTIES_FB = 1000119001, + XR_TYPE_RENDER_MODEL_BUFFER_FB = 1000119002, + XR_TYPE_RENDER_MODEL_LOAD_INFO_FB = 1000119003, + XR_TYPE_SYSTEM_RENDER_MODEL_PROPERTIES_FB = 1000119004, + XR_TYPE_BINDING_MODIFICATIONS_KHR = 1000120000, + XR_TYPE_VIEW_LOCATE_FOVEATED_RENDERING_VARJO = 1000121000, + XR_TYPE_FOVEATED_VIEW_CONFIGURATION_VIEW_VARJO = 1000121001, + XR_TYPE_SYSTEM_FOVEATED_RENDERING_PROPERTIES_VARJO = 1000121002, + XR_TYPE_COMPOSITION_LAYER_DEPTH_TEST_VARJO = 1000122000, + XR_TYPE_SYSTEM_MARKER_TRACKING_PROPERTIES_VARJO = 1000124000, + XR_TYPE_EVENT_DATA_MARKER_TRACKING_UPDATE_VARJO = 1000124001, + XR_TYPE_MARKER_SPACE_CREATE_INFO_VARJO = 1000124002, + XR_TYPE_SPATIAL_ANCHOR_PERSISTENCE_INFO_MSFT = 1000142000, + XR_TYPE_SPATIAL_ANCHOR_FROM_PERSISTED_ANCHOR_CREATE_INFO_MSFT = 1000142001, + XR_TYPE_SWAPCHAIN_IMAGE_FOVEATION_VULKAN_FB = 1000160000, + XR_TYPE_SWAPCHAIN_STATE_ANDROID_SURFACE_DIMENSIONS_FB = 1000161000, + XR_TYPE_SWAPCHAIN_STATE_SAMPLER_OPENGL_ES_FB = 1000162000, + XR_TYPE_SWAPCHAIN_STATE_SAMPLER_VULKAN_FB = 1000163000, + XR_TYPE_COMPOSITION_LAYER_SPACE_WARP_INFO_FB = 1000171000, + XR_TYPE_SYSTEM_SPACE_WARP_PROPERTIES_FB = 1000171001, + XR_TYPE_DIGITAL_LENS_CONTROL_ALMALENCE = 1000196000, + XR_TYPE_PASSTHROUGH_KEYBOARD_HANDS_INTENSITY_FB = 1000203002, + XR_TYPE_GRAPHICS_BINDING_VULKAN2_KHR = XR_TYPE_GRAPHICS_BINDING_VULKAN_KHR, + XR_TYPE_SWAPCHAIN_IMAGE_VULKAN2_KHR = XR_TYPE_SWAPCHAIN_IMAGE_VULKAN_KHR, + XR_TYPE_GRAPHICS_REQUIREMENTS_VULKAN2_KHR = XR_TYPE_GRAPHICS_REQUIREMENTS_VULKAN_KHR, + XR_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF +} XrStructureType; + +typedef enum XrFormFactor { + XR_FORM_FACTOR_HEAD_MOUNTED_DISPLAY = 1, + XR_FORM_FACTOR_HANDHELD_DISPLAY = 2, + XR_FORM_FACTOR_MAX_ENUM = 0x7FFFFFFF +} XrFormFactor; + +typedef enum XrViewConfigurationType { + XR_VIEW_CONFIGURATION_TYPE_PRIMARY_MONO = 1, + XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO = 2, + XR_VIEW_CONFIGURATION_TYPE_PRIMARY_QUAD_VARJO = 1000037000, + XR_VIEW_CONFIGURATION_TYPE_SECONDARY_MONO_FIRST_PERSON_OBSERVER_MSFT = 1000054000, + XR_VIEW_CONFIGURATION_TYPE_MAX_ENUM = 0x7FFFFFFF +} XrViewConfigurationType; + +typedef enum XrEnvironmentBlendMode { + XR_ENVIRONMENT_BLEND_MODE_OPAQUE = 1, + XR_ENVIRONMENT_BLEND_MODE_ADDITIVE = 2, + XR_ENVIRONMENT_BLEND_MODE_ALPHA_BLEND = 3, + XR_ENVIRONMENT_BLEND_MODE_MAX_ENUM = 0x7FFFFFFF +} XrEnvironmentBlendMode; + +typedef enum XrReferenceSpaceType { + XR_REFERENCE_SPACE_TYPE_VIEW = 1, + XR_REFERENCE_SPACE_TYPE_LOCAL = 2, + XR_REFERENCE_SPACE_TYPE_STAGE = 3, + XR_REFERENCE_SPACE_TYPE_UNBOUNDED_MSFT = 1000038000, + XR_REFERENCE_SPACE_TYPE_COMBINED_EYE_VARJO = 1000121000, + XR_REFERENCE_SPACE_TYPE_MAX_ENUM = 0x7FFFFFFF +} XrReferenceSpaceType; + +typedef enum XrActionType { + XR_ACTION_TYPE_BOOLEAN_INPUT = 1, + XR_ACTION_TYPE_FLOAT_INPUT = 2, + XR_ACTION_TYPE_VECTOR2F_INPUT = 3, + XR_ACTION_TYPE_POSE_INPUT = 4, + XR_ACTION_TYPE_VIBRATION_OUTPUT = 100, + XR_ACTION_TYPE_MAX_ENUM = 0x7FFFFFFF +} XrActionType; + +typedef enum XrEyeVisibility { + XR_EYE_VISIBILITY_BOTH = 0, + XR_EYE_VISIBILITY_LEFT = 1, + XR_EYE_VISIBILITY_RIGHT = 2, + XR_EYE_VISIBILITY_MAX_ENUM = 0x7FFFFFFF +} XrEyeVisibility; + +typedef enum XrSessionState { + XR_SESSION_STATE_UNKNOWN = 0, + XR_SESSION_STATE_IDLE = 1, + XR_SESSION_STATE_READY = 2, + XR_SESSION_STATE_SYNCHRONIZED = 3, + XR_SESSION_STATE_VISIBLE = 4, + XR_SESSION_STATE_FOCUSED = 5, + XR_SESSION_STATE_STOPPING = 6, + XR_SESSION_STATE_LOSS_PENDING = 7, + XR_SESSION_STATE_EXITING = 8, + XR_SESSION_STATE_MAX_ENUM = 0x7FFFFFFF +} XrSessionState; + +typedef enum XrObjectType { + XR_OBJECT_TYPE_UNKNOWN = 0, + XR_OBJECT_TYPE_INSTANCE = 1, + XR_OBJECT_TYPE_SESSION = 2, + XR_OBJECT_TYPE_SWAPCHAIN = 3, + XR_OBJECT_TYPE_SPACE = 4, + XR_OBJECT_TYPE_ACTION_SET = 5, + XR_OBJECT_TYPE_ACTION = 6, + XR_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT = 1000019000, + XR_OBJECT_TYPE_SPATIAL_ANCHOR_MSFT = 1000039000, + XR_OBJECT_TYPE_HAND_TRACKER_EXT = 1000051000, + XR_OBJECT_TYPE_SCENE_OBSERVER_MSFT = 1000097000, + XR_OBJECT_TYPE_SCENE_MSFT = 1000097001, + XR_OBJECT_TYPE_FACIAL_TRACKER_HTC = 1000104000, + XR_OBJECT_TYPE_FOVEATION_PROFILE_FB = 1000114000, + XR_OBJECT_TYPE_TRIANGLE_MESH_FB = 1000117000, + XR_OBJECT_TYPE_PASSTHROUGH_FB = 1000118000, + XR_OBJECT_TYPE_PASSTHROUGH_LAYER_FB = 1000118002, + XR_OBJECT_TYPE_GEOMETRY_INSTANCE_FB = 1000118004, + XR_OBJECT_TYPE_SPATIAL_ANCHOR_STORE_CONNECTION_MSFT = 1000142000, + XR_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF +} XrObjectType; +typedef XrFlags64 XrInstanceCreateFlags; + +// Flag bits for XrInstanceCreateFlags + +typedef XrFlags64 XrSessionCreateFlags; + +// Flag bits for XrSessionCreateFlags + +typedef XrFlags64 XrSpaceVelocityFlags; + +// Flag bits for XrSpaceVelocityFlags +static const XrSpaceVelocityFlags XR_SPACE_VELOCITY_LINEAR_VALID_BIT = 0x00000001; +static const XrSpaceVelocityFlags XR_SPACE_VELOCITY_ANGULAR_VALID_BIT = 0x00000002; + +typedef XrFlags64 XrSpaceLocationFlags; + +// Flag bits for XrSpaceLocationFlags +static const XrSpaceLocationFlags XR_SPACE_LOCATION_ORIENTATION_VALID_BIT = 0x00000001; +static const XrSpaceLocationFlags XR_SPACE_LOCATION_POSITION_VALID_BIT = 0x00000002; +static const XrSpaceLocationFlags XR_SPACE_LOCATION_ORIENTATION_TRACKED_BIT = 0x00000004; +static const XrSpaceLocationFlags XR_SPACE_LOCATION_POSITION_TRACKED_BIT = 0x00000008; + +typedef XrFlags64 XrSwapchainCreateFlags; + +// Flag bits for XrSwapchainCreateFlags +static const XrSwapchainCreateFlags XR_SWAPCHAIN_CREATE_PROTECTED_CONTENT_BIT = 0x00000001; +static const XrSwapchainCreateFlags XR_SWAPCHAIN_CREATE_STATIC_IMAGE_BIT = 0x00000002; + +typedef XrFlags64 XrSwapchainUsageFlags; + +// Flag bits for XrSwapchainUsageFlags +static const XrSwapchainUsageFlags XR_SWAPCHAIN_USAGE_COLOR_ATTACHMENT_BIT = 0x00000001; +static const XrSwapchainUsageFlags XR_SWAPCHAIN_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000002; +static const XrSwapchainUsageFlags XR_SWAPCHAIN_USAGE_UNORDERED_ACCESS_BIT = 0x00000004; +static const XrSwapchainUsageFlags XR_SWAPCHAIN_USAGE_TRANSFER_SRC_BIT = 0x00000008; +static const XrSwapchainUsageFlags XR_SWAPCHAIN_USAGE_TRANSFER_DST_BIT = 0x00000010; +static const XrSwapchainUsageFlags XR_SWAPCHAIN_USAGE_SAMPLED_BIT = 0x00000020; +static const XrSwapchainUsageFlags XR_SWAPCHAIN_USAGE_MUTABLE_FORMAT_BIT = 0x00000040; +static const XrSwapchainUsageFlags XR_SWAPCHAIN_USAGE_INPUT_ATTACHMENT_BIT_MND = 0x00000080; +static const XrSwapchainUsageFlags XR_SWAPCHAIN_USAGE_INPUT_ATTACHMENT_BIT_KHR = 0x00000080; // alias of XR_SWAPCHAIN_USAGE_INPUT_ATTACHMENT_BIT_MND + +typedef XrFlags64 XrCompositionLayerFlags; + +// Flag bits for XrCompositionLayerFlags +static const XrCompositionLayerFlags XR_COMPOSITION_LAYER_CORRECT_CHROMATIC_ABERRATION_BIT = 0x00000001; +static const XrCompositionLayerFlags XR_COMPOSITION_LAYER_BLEND_TEXTURE_SOURCE_ALPHA_BIT = 0x00000002; +static const XrCompositionLayerFlags XR_COMPOSITION_LAYER_UNPREMULTIPLIED_ALPHA_BIT = 0x00000004; + +typedef XrFlags64 XrViewStateFlags; + +// Flag bits for XrViewStateFlags +static const XrViewStateFlags XR_VIEW_STATE_ORIENTATION_VALID_BIT = 0x00000001; +static const XrViewStateFlags XR_VIEW_STATE_POSITION_VALID_BIT = 0x00000002; +static const XrViewStateFlags XR_VIEW_STATE_ORIENTATION_TRACKED_BIT = 0x00000004; +static const XrViewStateFlags XR_VIEW_STATE_POSITION_TRACKED_BIT = 0x00000008; + +typedef XrFlags64 XrInputSourceLocalizedNameFlags; + +// Flag bits for XrInputSourceLocalizedNameFlags +static const XrInputSourceLocalizedNameFlags XR_INPUT_SOURCE_LOCALIZED_NAME_USER_PATH_BIT = 0x00000001; +static const XrInputSourceLocalizedNameFlags XR_INPUT_SOURCE_LOCALIZED_NAME_INTERACTION_PROFILE_BIT = 0x00000002; +static const XrInputSourceLocalizedNameFlags XR_INPUT_SOURCE_LOCALIZED_NAME_COMPONENT_BIT = 0x00000004; + +typedef void (XRAPI_PTR *PFN_xrVoidFunction)(void); +typedef struct XrApiLayerProperties { + XrStructureType type; + void* XR_MAY_ALIAS next; + char layerName[XR_MAX_API_LAYER_NAME_SIZE]; + XrVersion specVersion; + uint32_t layerVersion; + char description[XR_MAX_API_LAYER_DESCRIPTION_SIZE]; +} XrApiLayerProperties; + +typedef struct XrExtensionProperties { + XrStructureType type; + void* XR_MAY_ALIAS next; + char extensionName[XR_MAX_EXTENSION_NAME_SIZE]; + uint32_t extensionVersion; +} XrExtensionProperties; + +typedef struct XrApplicationInfo { + char applicationName[XR_MAX_APPLICATION_NAME_SIZE]; + uint32_t applicationVersion; + char engineName[XR_MAX_ENGINE_NAME_SIZE]; + uint32_t engineVersion; + XrVersion apiVersion; +} XrApplicationInfo; + +typedef struct XrInstanceCreateInfo { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrInstanceCreateFlags createFlags; + XrApplicationInfo applicationInfo; + uint32_t enabledApiLayerCount; + const char* const* enabledApiLayerNames; + uint32_t enabledExtensionCount; + const char* const* enabledExtensionNames; +} XrInstanceCreateInfo; + +typedef struct XrInstanceProperties { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrVersion runtimeVersion; + char runtimeName[XR_MAX_RUNTIME_NAME_SIZE]; +} XrInstanceProperties; + +typedef struct XrEventDataBuffer { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint8_t varying[4000]; +} XrEventDataBuffer; + +typedef struct XrSystemGetInfo { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrFormFactor formFactor; +} XrSystemGetInfo; + +typedef struct XrSystemGraphicsProperties { + uint32_t maxSwapchainImageHeight; + uint32_t maxSwapchainImageWidth; + uint32_t maxLayerCount; +} XrSystemGraphicsProperties; + +typedef struct XrSystemTrackingProperties { + XrBool32 orientationTracking; + XrBool32 positionTracking; +} XrSystemTrackingProperties; + +typedef struct XrSystemProperties { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrSystemId systemId; + uint32_t vendorId; + char systemName[XR_MAX_SYSTEM_NAME_SIZE]; + XrSystemGraphicsProperties graphicsProperties; + XrSystemTrackingProperties trackingProperties; +} XrSystemProperties; + +typedef struct XrSessionCreateInfo { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSessionCreateFlags createFlags; + XrSystemId systemId; +} XrSessionCreateInfo; + +typedef struct XrVector3f { + float x; + float y; + float z; +} XrVector3f; + +// XrSpaceVelocity extends XrSpaceLocation +typedef struct XrSpaceVelocity { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrSpaceVelocityFlags velocityFlags; + XrVector3f linearVelocity; + XrVector3f angularVelocity; +} XrSpaceVelocity; + +typedef struct XrQuaternionf { + float x; + float y; + float z; + float w; +} XrQuaternionf; + +typedef struct XrPosef { + XrQuaternionf orientation; + XrVector3f position; +} XrPosef; + +typedef struct XrReferenceSpaceCreateInfo { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrReferenceSpaceType referenceSpaceType; + XrPosef poseInReferenceSpace; +} XrReferenceSpaceCreateInfo; + +typedef struct XrExtent2Df { + float width; + float height; +} XrExtent2Df; + +typedef struct XrActionSpaceCreateInfo { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrAction action; + XrPath subactionPath; + XrPosef poseInActionSpace; +} XrActionSpaceCreateInfo; + +typedef struct XrSpaceLocation { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrSpaceLocationFlags locationFlags; + XrPosef pose; +} XrSpaceLocation; + +typedef struct XrViewConfigurationProperties { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrViewConfigurationType viewConfigurationType; + XrBool32 fovMutable; +} XrViewConfigurationProperties; + +typedef struct XrViewConfigurationView { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t recommendedImageRectWidth; + uint32_t maxImageRectWidth; + uint32_t recommendedImageRectHeight; + uint32_t maxImageRectHeight; + uint32_t recommendedSwapchainSampleCount; + uint32_t maxSwapchainSampleCount; +} XrViewConfigurationView; + +typedef struct XrSwapchainCreateInfo { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSwapchainCreateFlags createFlags; + XrSwapchainUsageFlags usageFlags; + int64_t format; + uint32_t sampleCount; + uint32_t width; + uint32_t height; + uint32_t faceCount; + uint32_t arraySize; + uint32_t mipCount; +} XrSwapchainCreateInfo; + +typedef struct XR_MAY_ALIAS XrSwapchainImageBaseHeader { + XrStructureType type; + void* XR_MAY_ALIAS next; +} XrSwapchainImageBaseHeader; + +typedef struct XrSwapchainImageAcquireInfo { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrSwapchainImageAcquireInfo; + +typedef struct XrSwapchainImageWaitInfo { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrDuration timeout; +} XrSwapchainImageWaitInfo; + +typedef struct XrSwapchainImageReleaseInfo { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrSwapchainImageReleaseInfo; + +typedef struct XrSessionBeginInfo { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrViewConfigurationType primaryViewConfigurationType; +} XrSessionBeginInfo; + +typedef struct XrFrameWaitInfo { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrFrameWaitInfo; + +typedef struct XrFrameState { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrTime predictedDisplayTime; + XrDuration predictedDisplayPeriod; + XrBool32 shouldRender; +} XrFrameState; + +typedef struct XrFrameBeginInfo { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrFrameBeginInfo; + +typedef struct XR_MAY_ALIAS XrCompositionLayerBaseHeader { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrCompositionLayerFlags layerFlags; + XrSpace space; +} XrCompositionLayerBaseHeader; + +typedef struct XrFrameEndInfo { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrTime displayTime; + XrEnvironmentBlendMode environmentBlendMode; + uint32_t layerCount; + const XrCompositionLayerBaseHeader* const* layers; +} XrFrameEndInfo; + +typedef struct XrViewLocateInfo { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrViewConfigurationType viewConfigurationType; + XrTime displayTime; + XrSpace space; +} XrViewLocateInfo; + +typedef struct XrViewState { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrViewStateFlags viewStateFlags; +} XrViewState; + +typedef struct XrFovf { + float angleLeft; + float angleRight; + float angleUp; + float angleDown; +} XrFovf; + +typedef struct XrView { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrPosef pose; + XrFovf fov; +} XrView; + +typedef struct XrActionSetCreateInfo { + XrStructureType type; + const void* XR_MAY_ALIAS next; + char actionSetName[XR_MAX_ACTION_SET_NAME_SIZE]; + char localizedActionSetName[XR_MAX_LOCALIZED_ACTION_SET_NAME_SIZE]; + uint32_t priority; +} XrActionSetCreateInfo; + +typedef struct XrActionCreateInfo { + XrStructureType type; + const void* XR_MAY_ALIAS next; + char actionName[XR_MAX_ACTION_NAME_SIZE]; + XrActionType actionType; + uint32_t countSubactionPaths; + const XrPath* subactionPaths; + char localizedActionName[XR_MAX_LOCALIZED_ACTION_NAME_SIZE]; +} XrActionCreateInfo; + +typedef struct XrActionSuggestedBinding { + XrAction action; + XrPath binding; +} XrActionSuggestedBinding; + +typedef struct XrInteractionProfileSuggestedBinding { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrPath interactionProfile; + uint32_t countSuggestedBindings; + const XrActionSuggestedBinding* suggestedBindings; +} XrInteractionProfileSuggestedBinding; + +typedef struct XrSessionActionSetsAttachInfo { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t countActionSets; + const XrActionSet* actionSets; +} XrSessionActionSetsAttachInfo; + +typedef struct XrInteractionProfileState { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrPath interactionProfile; +} XrInteractionProfileState; + +typedef struct XrActionStateGetInfo { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrAction action; + XrPath subactionPath; +} XrActionStateGetInfo; + +typedef struct XrActionStateBoolean { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 currentState; + XrBool32 changedSinceLastSync; + XrTime lastChangeTime; + XrBool32 isActive; +} XrActionStateBoolean; + +typedef struct XrActionStateFloat { + XrStructureType type; + void* XR_MAY_ALIAS next; + float currentState; + XrBool32 changedSinceLastSync; + XrTime lastChangeTime; + XrBool32 isActive; +} XrActionStateFloat; + +typedef struct XrVector2f { + float x; + float y; +} XrVector2f; + +typedef struct XrActionStateVector2f { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrVector2f currentState; + XrBool32 changedSinceLastSync; + XrTime lastChangeTime; + XrBool32 isActive; +} XrActionStateVector2f; + +typedef struct XrActionStatePose { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 isActive; +} XrActionStatePose; + +typedef struct XrActiveActionSet { + XrActionSet actionSet; + XrPath subactionPath; +} XrActiveActionSet; + +typedef struct XrActionsSyncInfo { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t countActiveActionSets; + const XrActiveActionSet* activeActionSets; +} XrActionsSyncInfo; + +typedef struct XrBoundSourcesForActionEnumerateInfo { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrAction action; +} XrBoundSourcesForActionEnumerateInfo; + +typedef struct XrInputSourceLocalizedNameGetInfo { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrPath sourcePath; + XrInputSourceLocalizedNameFlags whichComponents; +} XrInputSourceLocalizedNameGetInfo; + +typedef struct XrHapticActionInfo { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrAction action; + XrPath subactionPath; +} XrHapticActionInfo; + +typedef struct XR_MAY_ALIAS XrHapticBaseHeader { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrHapticBaseHeader; + +typedef struct XR_MAY_ALIAS XrBaseInStructure { + XrStructureType type; + const struct XrBaseInStructure* next; +} XrBaseInStructure; + +typedef struct XR_MAY_ALIAS XrBaseOutStructure { + XrStructureType type; + struct XrBaseOutStructure* next; +} XrBaseOutStructure; + +typedef struct XrOffset2Di { + int32_t x; + int32_t y; +} XrOffset2Di; + +typedef struct XrExtent2Di { + int32_t width; + int32_t height; +} XrExtent2Di; + +typedef struct XrRect2Di { + XrOffset2Di offset; + XrExtent2Di extent; +} XrRect2Di; + +typedef struct XrSwapchainSubImage { + XrSwapchain swapchain; + XrRect2Di imageRect; + uint32_t imageArrayIndex; +} XrSwapchainSubImage; + +typedef struct XrCompositionLayerProjectionView { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrPosef pose; + XrFovf fov; + XrSwapchainSubImage subImage; +} XrCompositionLayerProjectionView; + +typedef struct XrCompositionLayerProjection { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrCompositionLayerFlags layerFlags; + XrSpace space; + uint32_t viewCount; + const XrCompositionLayerProjectionView* views; +} XrCompositionLayerProjection; + +typedef struct XrCompositionLayerQuad { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrCompositionLayerFlags layerFlags; + XrSpace space; + XrEyeVisibility eyeVisibility; + XrSwapchainSubImage subImage; + XrPosef pose; + XrExtent2Df size; +} XrCompositionLayerQuad; + +typedef struct XR_MAY_ALIAS XrEventDataBaseHeader { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrEventDataBaseHeader; + +typedef struct XrEventDataEventsLost { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t lostEventCount; +} XrEventDataEventsLost; + +typedef struct XrEventDataInstanceLossPending { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrTime lossTime; +} XrEventDataInstanceLossPending; + +typedef struct XrEventDataSessionStateChanged { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSession session; + XrSessionState state; + XrTime time; +} XrEventDataSessionStateChanged; + +typedef struct XrEventDataReferenceSpaceChangePending { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSession session; + XrReferenceSpaceType referenceSpaceType; + XrTime changeTime; + XrBool32 poseValid; + XrPosef poseInPreviousSpace; +} XrEventDataReferenceSpaceChangePending; + +typedef struct XrEventDataInteractionProfileChanged { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSession session; +} XrEventDataInteractionProfileChanged; + +typedef struct XrHapticVibration { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrDuration duration; + float frequency; + float amplitude; +} XrHapticVibration; + +typedef struct XrOffset2Df { + float x; + float y; +} XrOffset2Df; + +typedef struct XrRect2Df { + XrOffset2Df offset; + XrExtent2Df extent; +} XrRect2Df; + +typedef struct XrVector4f { + float x; + float y; + float z; + float w; +} XrVector4f; + +typedef struct XrColor4f { + float r; + float g; + float b; + float a; +} XrColor4f; + +typedef XrResult (XRAPI_PTR *PFN_xrGetInstanceProcAddr)(XrInstance instance, const char* name, PFN_xrVoidFunction* function); +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateApiLayerProperties)(uint32_t propertyCapacityInput, uint32_t* propertyCountOutput, XrApiLayerProperties* properties); +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateInstanceExtensionProperties)(const char* layerName, uint32_t propertyCapacityInput, uint32_t* propertyCountOutput, XrExtensionProperties* properties); +typedef XrResult (XRAPI_PTR *PFN_xrCreateInstance)(const XrInstanceCreateInfo* createInfo, XrInstance* instance); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyInstance)(XrInstance instance); +typedef XrResult (XRAPI_PTR *PFN_xrGetInstanceProperties)(XrInstance instance, XrInstanceProperties* instanceProperties); +typedef XrResult (XRAPI_PTR *PFN_xrPollEvent)(XrInstance instance, XrEventDataBuffer* eventData); +typedef XrResult (XRAPI_PTR *PFN_xrResultToString)(XrInstance instance, XrResult value, char buffer[XR_MAX_RESULT_STRING_SIZE]); +typedef XrResult (XRAPI_PTR *PFN_xrStructureTypeToString)(XrInstance instance, XrStructureType value, char buffer[XR_MAX_STRUCTURE_NAME_SIZE]); +typedef XrResult (XRAPI_PTR *PFN_xrGetSystem)(XrInstance instance, const XrSystemGetInfo* getInfo, XrSystemId* systemId); +typedef XrResult (XRAPI_PTR *PFN_xrGetSystemProperties)(XrInstance instance, XrSystemId systemId, XrSystemProperties* properties); +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateEnvironmentBlendModes)(XrInstance instance, XrSystemId systemId, XrViewConfigurationType viewConfigurationType, uint32_t environmentBlendModeCapacityInput, uint32_t* environmentBlendModeCountOutput, XrEnvironmentBlendMode* environmentBlendModes); +typedef XrResult (XRAPI_PTR *PFN_xrCreateSession)(XrInstance instance, const XrSessionCreateInfo* createInfo, XrSession* session); +typedef XrResult (XRAPI_PTR *PFN_xrDestroySession)(XrSession session); +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateReferenceSpaces)(XrSession session, uint32_t spaceCapacityInput, uint32_t* spaceCountOutput, XrReferenceSpaceType* spaces); +typedef XrResult (XRAPI_PTR *PFN_xrCreateReferenceSpace)(XrSession session, const XrReferenceSpaceCreateInfo* createInfo, XrSpace* space); +typedef XrResult (XRAPI_PTR *PFN_xrGetReferenceSpaceBoundsRect)(XrSession session, XrReferenceSpaceType referenceSpaceType, XrExtent2Df* bounds); +typedef XrResult (XRAPI_PTR *PFN_xrCreateActionSpace)(XrSession session, const XrActionSpaceCreateInfo* createInfo, XrSpace* space); +typedef XrResult (XRAPI_PTR *PFN_xrLocateSpace)(XrSpace space, XrSpace baseSpace, XrTime time, XrSpaceLocation* location); +typedef XrResult (XRAPI_PTR *PFN_xrDestroySpace)(XrSpace space); +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateViewConfigurations)(XrInstance instance, XrSystemId systemId, uint32_t viewConfigurationTypeCapacityInput, uint32_t* viewConfigurationTypeCountOutput, XrViewConfigurationType* viewConfigurationTypes); +typedef XrResult (XRAPI_PTR *PFN_xrGetViewConfigurationProperties)(XrInstance instance, XrSystemId systemId, XrViewConfigurationType viewConfigurationType, XrViewConfigurationProperties* configurationProperties); +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateViewConfigurationViews)(XrInstance instance, XrSystemId systemId, XrViewConfigurationType viewConfigurationType, uint32_t viewCapacityInput, uint32_t* viewCountOutput, XrViewConfigurationView* views); +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSwapchainFormats)(XrSession session, uint32_t formatCapacityInput, uint32_t* formatCountOutput, int64_t* formats); +typedef XrResult (XRAPI_PTR *PFN_xrCreateSwapchain)(XrSession session, const XrSwapchainCreateInfo* createInfo, XrSwapchain* swapchain); +typedef XrResult (XRAPI_PTR *PFN_xrDestroySwapchain)(XrSwapchain swapchain); +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSwapchainImages)(XrSwapchain swapchain, uint32_t imageCapacityInput, uint32_t* imageCountOutput, XrSwapchainImageBaseHeader* images); +typedef XrResult (XRAPI_PTR *PFN_xrAcquireSwapchainImage)(XrSwapchain swapchain, const XrSwapchainImageAcquireInfo* acquireInfo, uint32_t* index); +typedef XrResult (XRAPI_PTR *PFN_xrWaitSwapchainImage)(XrSwapchain swapchain, const XrSwapchainImageWaitInfo* waitInfo); +typedef XrResult (XRAPI_PTR *PFN_xrReleaseSwapchainImage)(XrSwapchain swapchain, const XrSwapchainImageReleaseInfo* releaseInfo); +typedef XrResult (XRAPI_PTR *PFN_xrBeginSession)(XrSession session, const XrSessionBeginInfo* beginInfo); +typedef XrResult (XRAPI_PTR *PFN_xrEndSession)(XrSession session); +typedef XrResult (XRAPI_PTR *PFN_xrRequestExitSession)(XrSession session); +typedef XrResult (XRAPI_PTR *PFN_xrWaitFrame)(XrSession session, const XrFrameWaitInfo* frameWaitInfo, XrFrameState* frameState); +typedef XrResult (XRAPI_PTR *PFN_xrBeginFrame)(XrSession session, const XrFrameBeginInfo* frameBeginInfo); +typedef XrResult (XRAPI_PTR *PFN_xrEndFrame)(XrSession session, const XrFrameEndInfo* frameEndInfo); +typedef XrResult (XRAPI_PTR *PFN_xrLocateViews)(XrSession session, const XrViewLocateInfo* viewLocateInfo, XrViewState* viewState, uint32_t viewCapacityInput, uint32_t* viewCountOutput, XrView* views); +typedef XrResult (XRAPI_PTR *PFN_xrStringToPath)(XrInstance instance, const char* pathString, XrPath* path); +typedef XrResult (XRAPI_PTR *PFN_xrPathToString)(XrInstance instance, XrPath path, uint32_t bufferCapacityInput, uint32_t* bufferCountOutput, char* buffer); +typedef XrResult (XRAPI_PTR *PFN_xrCreateActionSet)(XrInstance instance, const XrActionSetCreateInfo* createInfo, XrActionSet* actionSet); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyActionSet)(XrActionSet actionSet); +typedef XrResult (XRAPI_PTR *PFN_xrCreateAction)(XrActionSet actionSet, const XrActionCreateInfo* createInfo, XrAction* action); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyAction)(XrAction action); +typedef XrResult (XRAPI_PTR *PFN_xrSuggestInteractionProfileBindings)(XrInstance instance, const XrInteractionProfileSuggestedBinding* suggestedBindings); +typedef XrResult (XRAPI_PTR *PFN_xrAttachSessionActionSets)(XrSession session, const XrSessionActionSetsAttachInfo* attachInfo); +typedef XrResult (XRAPI_PTR *PFN_xrGetCurrentInteractionProfile)(XrSession session, XrPath topLevelUserPath, XrInteractionProfileState* interactionProfile); +typedef XrResult (XRAPI_PTR *PFN_xrGetActionStateBoolean)(XrSession session, const XrActionStateGetInfo* getInfo, XrActionStateBoolean* state); +typedef XrResult (XRAPI_PTR *PFN_xrGetActionStateFloat)(XrSession session, const XrActionStateGetInfo* getInfo, XrActionStateFloat* state); +typedef XrResult (XRAPI_PTR *PFN_xrGetActionStateVector2f)(XrSession session, const XrActionStateGetInfo* getInfo, XrActionStateVector2f* state); +typedef XrResult (XRAPI_PTR *PFN_xrGetActionStatePose)(XrSession session, const XrActionStateGetInfo* getInfo, XrActionStatePose* state); +typedef XrResult (XRAPI_PTR *PFN_xrSyncActions)(XrSession session, const XrActionsSyncInfo* syncInfo); +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateBoundSourcesForAction)(XrSession session, const XrBoundSourcesForActionEnumerateInfo* enumerateInfo, uint32_t sourceCapacityInput, uint32_t* sourceCountOutput, XrPath* sources); +typedef XrResult (XRAPI_PTR *PFN_xrGetInputSourceLocalizedName)(XrSession session, const XrInputSourceLocalizedNameGetInfo* getInfo, uint32_t bufferCapacityInput, uint32_t* bufferCountOutput, char* buffer); +typedef XrResult (XRAPI_PTR *PFN_xrApplyHapticFeedback)(XrSession session, const XrHapticActionInfo* hapticActionInfo, const XrHapticBaseHeader* hapticFeedback); +typedef XrResult (XRAPI_PTR *PFN_xrStopHapticFeedback)(XrSession session, const XrHapticActionInfo* hapticActionInfo); + +#ifndef XR_NO_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrGetInstanceProcAddr( + XrInstance instance, + const char* name, + PFN_xrVoidFunction* function); + +XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateApiLayerProperties( + uint32_t propertyCapacityInput, + uint32_t* propertyCountOutput, + XrApiLayerProperties* properties); + +XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateInstanceExtensionProperties( + const char* layerName, + uint32_t propertyCapacityInput, + uint32_t* propertyCountOutput, + XrExtensionProperties* properties); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateInstance( + const XrInstanceCreateInfo* createInfo, + XrInstance* instance); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyInstance( + XrInstance instance); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetInstanceProperties( + XrInstance instance, + XrInstanceProperties* instanceProperties); + +XRAPI_ATTR XrResult XRAPI_CALL xrPollEvent( + XrInstance instance, + XrEventDataBuffer* eventData); + +XRAPI_ATTR XrResult XRAPI_CALL xrResultToString( + XrInstance instance, + XrResult value, + char buffer[XR_MAX_RESULT_STRING_SIZE]); + +XRAPI_ATTR XrResult XRAPI_CALL xrStructureTypeToString( + XrInstance instance, + XrStructureType value, + char buffer[XR_MAX_STRUCTURE_NAME_SIZE]); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetSystem( + XrInstance instance, + const XrSystemGetInfo* getInfo, + XrSystemId* systemId); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetSystemProperties( + XrInstance instance, + XrSystemId systemId, + XrSystemProperties* properties); + +XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateEnvironmentBlendModes( + XrInstance instance, + XrSystemId systemId, + XrViewConfigurationType viewConfigurationType, + uint32_t environmentBlendModeCapacityInput, + uint32_t* environmentBlendModeCountOutput, + XrEnvironmentBlendMode* environmentBlendModes); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSession( + XrInstance instance, + const XrSessionCreateInfo* createInfo, + XrSession* session); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroySession( + XrSession session); + +XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateReferenceSpaces( + XrSession session, + uint32_t spaceCapacityInput, + uint32_t* spaceCountOutput, + XrReferenceSpaceType* spaces); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateReferenceSpace( + XrSession session, + const XrReferenceSpaceCreateInfo* createInfo, + XrSpace* space); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetReferenceSpaceBoundsRect( + XrSession session, + XrReferenceSpaceType referenceSpaceType, + XrExtent2Df* bounds); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateActionSpace( + XrSession session, + const XrActionSpaceCreateInfo* createInfo, + XrSpace* space); + +XRAPI_ATTR XrResult XRAPI_CALL xrLocateSpace( + XrSpace space, + XrSpace baseSpace, + XrTime time, + XrSpaceLocation* location); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroySpace( + XrSpace space); + +XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateViewConfigurations( + XrInstance instance, + XrSystemId systemId, + uint32_t viewConfigurationTypeCapacityInput, + uint32_t* viewConfigurationTypeCountOutput, + XrViewConfigurationType* viewConfigurationTypes); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetViewConfigurationProperties( + XrInstance instance, + XrSystemId systemId, + XrViewConfigurationType viewConfigurationType, + XrViewConfigurationProperties* configurationProperties); + +XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateViewConfigurationViews( + XrInstance instance, + XrSystemId systemId, + XrViewConfigurationType viewConfigurationType, + uint32_t viewCapacityInput, + uint32_t* viewCountOutput, + XrViewConfigurationView* views); + +XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateSwapchainFormats( + XrSession session, + uint32_t formatCapacityInput, + uint32_t* formatCountOutput, + int64_t* formats); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSwapchain( + XrSession session, + const XrSwapchainCreateInfo* createInfo, + XrSwapchain* swapchain); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroySwapchain( + XrSwapchain swapchain); + +XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateSwapchainImages( + XrSwapchain swapchain, + uint32_t imageCapacityInput, + uint32_t* imageCountOutput, + XrSwapchainImageBaseHeader* images); + +XRAPI_ATTR XrResult XRAPI_CALL xrAcquireSwapchainImage( + XrSwapchain swapchain, + const XrSwapchainImageAcquireInfo* acquireInfo, + uint32_t* index); + +XRAPI_ATTR XrResult XRAPI_CALL xrWaitSwapchainImage( + XrSwapchain swapchain, + const XrSwapchainImageWaitInfo* waitInfo); + +XRAPI_ATTR XrResult XRAPI_CALL xrReleaseSwapchainImage( + XrSwapchain swapchain, + const XrSwapchainImageReleaseInfo* releaseInfo); + +XRAPI_ATTR XrResult XRAPI_CALL xrBeginSession( + XrSession session, + const XrSessionBeginInfo* beginInfo); + +XRAPI_ATTR XrResult XRAPI_CALL xrEndSession( + XrSession session); + +XRAPI_ATTR XrResult XRAPI_CALL xrRequestExitSession( + XrSession session); + +XRAPI_ATTR XrResult XRAPI_CALL xrWaitFrame( + XrSession session, + const XrFrameWaitInfo* frameWaitInfo, + XrFrameState* frameState); + +XRAPI_ATTR XrResult XRAPI_CALL xrBeginFrame( + XrSession session, + const XrFrameBeginInfo* frameBeginInfo); + +XRAPI_ATTR XrResult XRAPI_CALL xrEndFrame( + XrSession session, + const XrFrameEndInfo* frameEndInfo); + +XRAPI_ATTR XrResult XRAPI_CALL xrLocateViews( + XrSession session, + const XrViewLocateInfo* viewLocateInfo, + XrViewState* viewState, + uint32_t viewCapacityInput, + uint32_t* viewCountOutput, + XrView* views); + +XRAPI_ATTR XrResult XRAPI_CALL xrStringToPath( + XrInstance instance, + const char* pathString, + XrPath* path); + +XRAPI_ATTR XrResult XRAPI_CALL xrPathToString( + XrInstance instance, + XrPath path, + uint32_t bufferCapacityInput, + uint32_t* bufferCountOutput, + char* buffer); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateActionSet( + XrInstance instance, + const XrActionSetCreateInfo* createInfo, + XrActionSet* actionSet); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyActionSet( + XrActionSet actionSet); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateAction( + XrActionSet actionSet, + const XrActionCreateInfo* createInfo, + XrAction* action); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyAction( + XrAction action); + +XRAPI_ATTR XrResult XRAPI_CALL xrSuggestInteractionProfileBindings( + XrInstance instance, + const XrInteractionProfileSuggestedBinding* suggestedBindings); + +XRAPI_ATTR XrResult XRAPI_CALL xrAttachSessionActionSets( + XrSession session, + const XrSessionActionSetsAttachInfo* attachInfo); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetCurrentInteractionProfile( + XrSession session, + XrPath topLevelUserPath, + XrInteractionProfileState* interactionProfile); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetActionStateBoolean( + XrSession session, + const XrActionStateGetInfo* getInfo, + XrActionStateBoolean* state); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetActionStateFloat( + XrSession session, + const XrActionStateGetInfo* getInfo, + XrActionStateFloat* state); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetActionStateVector2f( + XrSession session, + const XrActionStateGetInfo* getInfo, + XrActionStateVector2f* state); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetActionStatePose( + XrSession session, + const XrActionStateGetInfo* getInfo, + XrActionStatePose* state); + +XRAPI_ATTR XrResult XRAPI_CALL xrSyncActions( + XrSession session, + const XrActionsSyncInfo* syncInfo); + +XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateBoundSourcesForAction( + XrSession session, + const XrBoundSourcesForActionEnumerateInfo* enumerateInfo, + uint32_t sourceCapacityInput, + uint32_t* sourceCountOutput, + XrPath* sources); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetInputSourceLocalizedName( + XrSession session, + const XrInputSourceLocalizedNameGetInfo* getInfo, + uint32_t bufferCapacityInput, + uint32_t* bufferCountOutput, + char* buffer); + +XRAPI_ATTR XrResult XRAPI_CALL xrApplyHapticFeedback( + XrSession session, + const XrHapticActionInfo* hapticActionInfo, + const XrHapticBaseHeader* hapticFeedback); + +XRAPI_ATTR XrResult XRAPI_CALL xrStopHapticFeedback( + XrSession session, + const XrHapticActionInfo* hapticActionInfo); +#endif /* !XR_NO_PROTOTYPES */ + + +#define XR_KHR_composition_layer_cube 1 +#define XR_KHR_composition_layer_cube_SPEC_VERSION 8 +#define XR_KHR_COMPOSITION_LAYER_CUBE_EXTENSION_NAME "XR_KHR_composition_layer_cube" +typedef struct XrCompositionLayerCubeKHR { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrCompositionLayerFlags layerFlags; + XrSpace space; + XrEyeVisibility eyeVisibility; + XrSwapchain swapchain; + uint32_t imageArrayIndex; + XrQuaternionf orientation; +} XrCompositionLayerCubeKHR; + + + +#define XR_KHR_composition_layer_depth 1 +#define XR_KHR_composition_layer_depth_SPEC_VERSION 5 +#define XR_KHR_COMPOSITION_LAYER_DEPTH_EXTENSION_NAME "XR_KHR_composition_layer_depth" +// XrCompositionLayerDepthInfoKHR extends XrCompositionLayerProjectionView +typedef struct XrCompositionLayerDepthInfoKHR { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSwapchainSubImage subImage; + float minDepth; + float maxDepth; + float nearZ; + float farZ; +} XrCompositionLayerDepthInfoKHR; + + + +#define XR_KHR_composition_layer_cylinder 1 +#define XR_KHR_composition_layer_cylinder_SPEC_VERSION 4 +#define XR_KHR_COMPOSITION_LAYER_CYLINDER_EXTENSION_NAME "XR_KHR_composition_layer_cylinder" +typedef struct XrCompositionLayerCylinderKHR { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrCompositionLayerFlags layerFlags; + XrSpace space; + XrEyeVisibility eyeVisibility; + XrSwapchainSubImage subImage; + XrPosef pose; + float radius; + float centralAngle; + float aspectRatio; +} XrCompositionLayerCylinderKHR; + + + +#define XR_KHR_composition_layer_equirect 1 +#define XR_KHR_composition_layer_equirect_SPEC_VERSION 3 +#define XR_KHR_COMPOSITION_LAYER_EQUIRECT_EXTENSION_NAME "XR_KHR_composition_layer_equirect" +typedef struct XrCompositionLayerEquirectKHR { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrCompositionLayerFlags layerFlags; + XrSpace space; + XrEyeVisibility eyeVisibility; + XrSwapchainSubImage subImage; + XrPosef pose; + float radius; + XrVector2f scale; + XrVector2f bias; +} XrCompositionLayerEquirectKHR; + + + +#define XR_KHR_visibility_mask 1 +#define XR_KHR_visibility_mask_SPEC_VERSION 2 +#define XR_KHR_VISIBILITY_MASK_EXTENSION_NAME "XR_KHR_visibility_mask" + +typedef enum XrVisibilityMaskTypeKHR { + XR_VISIBILITY_MASK_TYPE_HIDDEN_TRIANGLE_MESH_KHR = 1, + XR_VISIBILITY_MASK_TYPE_VISIBLE_TRIANGLE_MESH_KHR = 2, + XR_VISIBILITY_MASK_TYPE_LINE_LOOP_KHR = 3, + XR_VISIBILITY_MASK_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF +} XrVisibilityMaskTypeKHR; +typedef struct XrVisibilityMaskKHR { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t vertexCapacityInput; + uint32_t vertexCountOutput; + XrVector2f* vertices; + uint32_t indexCapacityInput; + uint32_t indexCountOutput; + uint32_t* indices; +} XrVisibilityMaskKHR; + +typedef struct XrEventDataVisibilityMaskChangedKHR { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSession session; + XrViewConfigurationType viewConfigurationType; + uint32_t viewIndex; +} XrEventDataVisibilityMaskChangedKHR; + +typedef XrResult (XRAPI_PTR *PFN_xrGetVisibilityMaskKHR)(XrSession session, XrViewConfigurationType viewConfigurationType, uint32_t viewIndex, XrVisibilityMaskTypeKHR visibilityMaskType, XrVisibilityMaskKHR* visibilityMask); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrGetVisibilityMaskKHR( + XrSession session, + XrViewConfigurationType viewConfigurationType, + uint32_t viewIndex, + XrVisibilityMaskTypeKHR visibilityMaskType, + XrVisibilityMaskKHR* visibilityMask); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +#define XR_KHR_composition_layer_color_scale_bias 1 +#define XR_KHR_composition_layer_color_scale_bias_SPEC_VERSION 5 +#define XR_KHR_COMPOSITION_LAYER_COLOR_SCALE_BIAS_EXTENSION_NAME "XR_KHR_composition_layer_color_scale_bias" +// XrCompositionLayerColorScaleBiasKHR extends XrCompositionLayerBaseHeader +typedef struct XrCompositionLayerColorScaleBiasKHR { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrColor4f colorScale; + XrColor4f colorBias; +} XrCompositionLayerColorScaleBiasKHR; + + + +#define XR_KHR_loader_init 1 +#define XR_KHR_loader_init_SPEC_VERSION 1 +#define XR_KHR_LOADER_INIT_EXTENSION_NAME "XR_KHR_loader_init" +typedef struct XR_MAY_ALIAS XrLoaderInitInfoBaseHeaderKHR { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrLoaderInitInfoBaseHeaderKHR; + +typedef XrResult (XRAPI_PTR *PFN_xrInitializeLoaderKHR)(const XrLoaderInitInfoBaseHeaderKHR* loaderInitInfo); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrInitializeLoaderKHR( + const XrLoaderInitInfoBaseHeaderKHR* loaderInitInfo); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +#define XR_KHR_composition_layer_equirect2 1 +#define XR_KHR_composition_layer_equirect2_SPEC_VERSION 1 +#define XR_KHR_COMPOSITION_LAYER_EQUIRECT2_EXTENSION_NAME "XR_KHR_composition_layer_equirect2" +typedef struct XrCompositionLayerEquirect2KHR { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrCompositionLayerFlags layerFlags; + XrSpace space; + XrEyeVisibility eyeVisibility; + XrSwapchainSubImage subImage; + XrPosef pose; + float radius; + float centralHorizontalAngle; + float upperVerticalAngle; + float lowerVerticalAngle; +} XrCompositionLayerEquirect2KHR; + + + +#define XR_KHR_binding_modification 1 +#define XR_KHR_binding_modification_SPEC_VERSION 1 +#define XR_KHR_BINDING_MODIFICATION_EXTENSION_NAME "XR_KHR_binding_modification" +typedef struct XR_MAY_ALIAS XrBindingModificationBaseHeaderKHR { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrBindingModificationBaseHeaderKHR; + +// XrBindingModificationsKHR extends XrInteractionProfileSuggestedBinding +typedef struct XrBindingModificationsKHR { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t bindingModificationCount; + const XrBindingModificationBaseHeaderKHR* const* bindingModifications; +} XrBindingModificationsKHR; + + + +#define XR_KHR_swapchain_usage_input_attachment_bit 1 +#define XR_KHR_swapchain_usage_input_attachment_bit_SPEC_VERSION 3 +#define XR_KHR_SWAPCHAIN_USAGE_INPUT_ATTACHMENT_BIT_EXTENSION_NAME "XR_KHR_swapchain_usage_input_attachment_bit" + + +#define XR_EXT_performance_settings 1 +#define XR_EXT_performance_settings_SPEC_VERSION 3 +#define XR_EXT_PERFORMANCE_SETTINGS_EXTENSION_NAME "XR_EXT_performance_settings" + +typedef enum XrPerfSettingsDomainEXT { + XR_PERF_SETTINGS_DOMAIN_CPU_EXT = 1, + XR_PERF_SETTINGS_DOMAIN_GPU_EXT = 2, + XR_PERF_SETTINGS_DOMAIN_MAX_ENUM_EXT = 0x7FFFFFFF +} XrPerfSettingsDomainEXT; + +typedef enum XrPerfSettingsSubDomainEXT { + XR_PERF_SETTINGS_SUB_DOMAIN_COMPOSITING_EXT = 1, + XR_PERF_SETTINGS_SUB_DOMAIN_RENDERING_EXT = 2, + XR_PERF_SETTINGS_SUB_DOMAIN_THERMAL_EXT = 3, + XR_PERF_SETTINGS_SUB_DOMAIN_MAX_ENUM_EXT = 0x7FFFFFFF +} XrPerfSettingsSubDomainEXT; + +typedef enum XrPerfSettingsLevelEXT { + XR_PERF_SETTINGS_LEVEL_POWER_SAVINGS_EXT = 0, + XR_PERF_SETTINGS_LEVEL_SUSTAINED_LOW_EXT = 25, + XR_PERF_SETTINGS_LEVEL_SUSTAINED_HIGH_EXT = 50, + XR_PERF_SETTINGS_LEVEL_BOOST_EXT = 75, + XR_PERF_SETTINGS_LEVEL_MAX_ENUM_EXT = 0x7FFFFFFF +} XrPerfSettingsLevelEXT; + +typedef enum XrPerfSettingsNotificationLevelEXT { + XR_PERF_SETTINGS_NOTIF_LEVEL_NORMAL_EXT = 0, + XR_PERF_SETTINGS_NOTIF_LEVEL_WARNING_EXT = 25, + XR_PERF_SETTINGS_NOTIF_LEVEL_IMPAIRED_EXT = 75, + XR_PERF_SETTINGS_NOTIFICATION_LEVEL_MAX_ENUM_EXT = 0x7FFFFFFF +} XrPerfSettingsNotificationLevelEXT; +typedef struct XrEventDataPerfSettingsEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrPerfSettingsDomainEXT domain; + XrPerfSettingsSubDomainEXT subDomain; + XrPerfSettingsNotificationLevelEXT fromLevel; + XrPerfSettingsNotificationLevelEXT toLevel; +} XrEventDataPerfSettingsEXT; + +typedef XrResult (XRAPI_PTR *PFN_xrPerfSettingsSetPerformanceLevelEXT)(XrSession session, XrPerfSettingsDomainEXT domain, XrPerfSettingsLevelEXT level); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrPerfSettingsSetPerformanceLevelEXT( + XrSession session, + XrPerfSettingsDomainEXT domain, + XrPerfSettingsLevelEXT level); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +#define XR_EXT_thermal_query 1 +#define XR_EXT_thermal_query_SPEC_VERSION 2 +#define XR_EXT_THERMAL_QUERY_EXTENSION_NAME "XR_EXT_thermal_query" +typedef XrResult (XRAPI_PTR *PFN_xrThermalGetTemperatureTrendEXT)(XrSession session, XrPerfSettingsDomainEXT domain, XrPerfSettingsNotificationLevelEXT* notificationLevel, float* tempHeadroom, float* tempSlope); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrThermalGetTemperatureTrendEXT( + XrSession session, + XrPerfSettingsDomainEXT domain, + XrPerfSettingsNotificationLevelEXT* notificationLevel, + float* tempHeadroom, + float* tempSlope); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +#define XR_EXT_debug_utils 1 +XR_DEFINE_HANDLE(XrDebugUtilsMessengerEXT) +#define XR_EXT_debug_utils_SPEC_VERSION 4 +#define XR_EXT_DEBUG_UTILS_EXTENSION_NAME "XR_EXT_debug_utils" +typedef XrFlags64 XrDebugUtilsMessageSeverityFlagsEXT; + +// Flag bits for XrDebugUtilsMessageSeverityFlagsEXT +static const XrDebugUtilsMessageSeverityFlagsEXT XR_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT = 0x00000001; +static const XrDebugUtilsMessageSeverityFlagsEXT XR_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT = 0x00000010; +static const XrDebugUtilsMessageSeverityFlagsEXT XR_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT = 0x00000100; +static const XrDebugUtilsMessageSeverityFlagsEXT XR_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT = 0x00001000; + +typedef XrFlags64 XrDebugUtilsMessageTypeFlagsEXT; + +// Flag bits for XrDebugUtilsMessageTypeFlagsEXT +static const XrDebugUtilsMessageTypeFlagsEXT XR_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT = 0x00000001; +static const XrDebugUtilsMessageTypeFlagsEXT XR_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT = 0x00000002; +static const XrDebugUtilsMessageTypeFlagsEXT XR_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT = 0x00000004; +static const XrDebugUtilsMessageTypeFlagsEXT XR_DEBUG_UTILS_MESSAGE_TYPE_CONFORMANCE_BIT_EXT = 0x00000008; + +typedef struct XrDebugUtilsObjectNameInfoEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrObjectType objectType; + uint64_t objectHandle; + const char* objectName; +} XrDebugUtilsObjectNameInfoEXT; + +typedef struct XrDebugUtilsLabelEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + const char* labelName; +} XrDebugUtilsLabelEXT; + +typedef struct XrDebugUtilsMessengerCallbackDataEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + const char* messageId; + const char* functionName; + const char* message; + uint32_t objectCount; + XrDebugUtilsObjectNameInfoEXT* objects; + uint32_t sessionLabelCount; + XrDebugUtilsLabelEXT* sessionLabels; +} XrDebugUtilsMessengerCallbackDataEXT; + +typedef XrBool32 (XRAPI_PTR *PFN_xrDebugUtilsMessengerCallbackEXT)( + XrDebugUtilsMessageSeverityFlagsEXT messageSeverity, + XrDebugUtilsMessageTypeFlagsEXT messageTypes, + const XrDebugUtilsMessengerCallbackDataEXT* callbackData, + void* userData); + + +// XrDebugUtilsMessengerCreateInfoEXT extends XrInstanceCreateInfo +typedef struct XrDebugUtilsMessengerCreateInfoEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrDebugUtilsMessageSeverityFlagsEXT messageSeverities; + XrDebugUtilsMessageTypeFlagsEXT messageTypes; + PFN_xrDebugUtilsMessengerCallbackEXT userCallback; + void* XR_MAY_ALIAS userData; +} XrDebugUtilsMessengerCreateInfoEXT; + +typedef XrResult (XRAPI_PTR *PFN_xrSetDebugUtilsObjectNameEXT)(XrInstance instance, const XrDebugUtilsObjectNameInfoEXT* nameInfo); +typedef XrResult (XRAPI_PTR *PFN_xrCreateDebugUtilsMessengerEXT)(XrInstance instance, const XrDebugUtilsMessengerCreateInfoEXT* createInfo, XrDebugUtilsMessengerEXT* messenger); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyDebugUtilsMessengerEXT)(XrDebugUtilsMessengerEXT messenger); +typedef XrResult (XRAPI_PTR *PFN_xrSubmitDebugUtilsMessageEXT)(XrInstance instance, XrDebugUtilsMessageSeverityFlagsEXT messageSeverity, XrDebugUtilsMessageTypeFlagsEXT messageTypes, const XrDebugUtilsMessengerCallbackDataEXT* callbackData); +typedef XrResult (XRAPI_PTR *PFN_xrSessionBeginDebugUtilsLabelRegionEXT)(XrSession session, const XrDebugUtilsLabelEXT* labelInfo); +typedef XrResult (XRAPI_PTR *PFN_xrSessionEndDebugUtilsLabelRegionEXT)(XrSession session); +typedef XrResult (XRAPI_PTR *PFN_xrSessionInsertDebugUtilsLabelEXT)(XrSession session, const XrDebugUtilsLabelEXT* labelInfo); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrSetDebugUtilsObjectNameEXT( + XrInstance instance, + const XrDebugUtilsObjectNameInfoEXT* nameInfo); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateDebugUtilsMessengerEXT( + XrInstance instance, + const XrDebugUtilsMessengerCreateInfoEXT* createInfo, + XrDebugUtilsMessengerEXT* messenger); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyDebugUtilsMessengerEXT( + XrDebugUtilsMessengerEXT messenger); + +XRAPI_ATTR XrResult XRAPI_CALL xrSubmitDebugUtilsMessageEXT( + XrInstance instance, + XrDebugUtilsMessageSeverityFlagsEXT messageSeverity, + XrDebugUtilsMessageTypeFlagsEXT messageTypes, + const XrDebugUtilsMessengerCallbackDataEXT* callbackData); + +XRAPI_ATTR XrResult XRAPI_CALL xrSessionBeginDebugUtilsLabelRegionEXT( + XrSession session, + const XrDebugUtilsLabelEXT* labelInfo); + +XRAPI_ATTR XrResult XRAPI_CALL xrSessionEndDebugUtilsLabelRegionEXT( + XrSession session); + +XRAPI_ATTR XrResult XRAPI_CALL xrSessionInsertDebugUtilsLabelEXT( + XrSession session, + const XrDebugUtilsLabelEXT* labelInfo); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +#define XR_EXT_eye_gaze_interaction 1 +#define XR_EXT_eye_gaze_interaction_SPEC_VERSION 1 +#define XR_EXT_EYE_GAZE_INTERACTION_EXTENSION_NAME "XR_EXT_eye_gaze_interaction" +// XrSystemEyeGazeInteractionPropertiesEXT extends XrSystemProperties +typedef struct XrSystemEyeGazeInteractionPropertiesEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsEyeGazeInteraction; +} XrSystemEyeGazeInteractionPropertiesEXT; + +// XrEyeGazeSampleTimeEXT extends XrSpaceLocation +typedef struct XrEyeGazeSampleTimeEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrTime time; +} XrEyeGazeSampleTimeEXT; + + + +#define XR_EXTX_overlay 1 +#define XR_EXTX_overlay_SPEC_VERSION 5 +#define XR_EXTX_OVERLAY_EXTENSION_NAME "XR_EXTX_overlay" +typedef XrFlags64 XrOverlaySessionCreateFlagsEXTX; + +// Flag bits for XrOverlaySessionCreateFlagsEXTX + +typedef XrFlags64 XrOverlayMainSessionFlagsEXTX; + +// Flag bits for XrOverlayMainSessionFlagsEXTX +static const XrOverlayMainSessionFlagsEXTX XR_OVERLAY_MAIN_SESSION_ENABLED_COMPOSITION_LAYER_INFO_DEPTH_BIT_EXTX = 0x00000001; + +// XrSessionCreateInfoOverlayEXTX extends XrSessionCreateInfo +typedef struct XrSessionCreateInfoOverlayEXTX { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrOverlaySessionCreateFlagsEXTX createFlags; + uint32_t sessionLayersPlacement; +} XrSessionCreateInfoOverlayEXTX; + +typedef struct XrEventDataMainSessionVisibilityChangedEXTX { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrBool32 visible; + XrOverlayMainSessionFlagsEXTX flags; +} XrEventDataMainSessionVisibilityChangedEXTX; + + + +#define XR_VARJO_quad_views 1 +#define XR_VARJO_quad_views_SPEC_VERSION 1 +#define XR_VARJO_QUAD_VIEWS_EXTENSION_NAME "XR_VARJO_quad_views" + + +#define XR_MSFT_unbounded_reference_space 1 +#define XR_MSFT_unbounded_reference_space_SPEC_VERSION 1 +#define XR_MSFT_UNBOUNDED_REFERENCE_SPACE_EXTENSION_NAME "XR_MSFT_unbounded_reference_space" + + +#define XR_MSFT_spatial_anchor 1 +XR_DEFINE_HANDLE(XrSpatialAnchorMSFT) +#define XR_MSFT_spatial_anchor_SPEC_VERSION 2 +#define XR_MSFT_SPATIAL_ANCHOR_EXTENSION_NAME "XR_MSFT_spatial_anchor" +typedef struct XrSpatialAnchorCreateInfoMSFT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpace space; + XrPosef pose; + XrTime time; +} XrSpatialAnchorCreateInfoMSFT; + +typedef struct XrSpatialAnchorSpaceCreateInfoMSFT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpatialAnchorMSFT anchor; + XrPosef poseInAnchorSpace; +} XrSpatialAnchorSpaceCreateInfoMSFT; + +typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorMSFT)(XrSession session, const XrSpatialAnchorCreateInfoMSFT* createInfo, XrSpatialAnchorMSFT* anchor); +typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorSpaceMSFT)(XrSession session, const XrSpatialAnchorSpaceCreateInfoMSFT* createInfo, XrSpace* space); +typedef XrResult (XRAPI_PTR *PFN_xrDestroySpatialAnchorMSFT)(XrSpatialAnchorMSFT anchor); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialAnchorMSFT( + XrSession session, + const XrSpatialAnchorCreateInfoMSFT* createInfo, + XrSpatialAnchorMSFT* anchor); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialAnchorSpaceMSFT( + XrSession session, + const XrSpatialAnchorSpaceCreateInfoMSFT* createInfo, + XrSpace* space); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroySpatialAnchorMSFT( + XrSpatialAnchorMSFT anchor); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +#define XR_FB_composition_layer_image_layout 1 +#define XR_FB_composition_layer_image_layout_SPEC_VERSION 1 +#define XR_FB_COMPOSITION_LAYER_IMAGE_LAYOUT_EXTENSION_NAME "XR_FB_composition_layer_image_layout" +typedef XrFlags64 XrCompositionLayerImageLayoutFlagsFB; + +// Flag bits for XrCompositionLayerImageLayoutFlagsFB +static const XrCompositionLayerImageLayoutFlagsFB XR_COMPOSITION_LAYER_IMAGE_LAYOUT_VERTICAL_FLIP_BIT_FB = 0x00000001; + +// XrCompositionLayerImageLayoutFB extends XrCompositionLayerBaseHeader +typedef struct XrCompositionLayerImageLayoutFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrCompositionLayerImageLayoutFlagsFB flags; +} XrCompositionLayerImageLayoutFB; + + + +#define XR_FB_composition_layer_alpha_blend 1 +#define XR_FB_composition_layer_alpha_blend_SPEC_VERSION 2 +#define XR_FB_COMPOSITION_LAYER_ALPHA_BLEND_EXTENSION_NAME "XR_FB_composition_layer_alpha_blend" + +typedef enum XrBlendFactorFB { + XR_BLEND_FACTOR_ZERO_FB = 0, + XR_BLEND_FACTOR_ONE_FB = 1, + XR_BLEND_FACTOR_SRC_ALPHA_FB = 2, + XR_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA_FB = 3, + XR_BLEND_FACTOR_DST_ALPHA_FB = 4, + XR_BLEND_FACTOR_ONE_MINUS_DST_ALPHA_FB = 5, + XR_BLEND_FACTOR_MAX_ENUM_FB = 0x7FFFFFFF +} XrBlendFactorFB; +// XrCompositionLayerAlphaBlendFB extends XrCompositionLayerBaseHeader +typedef struct XrCompositionLayerAlphaBlendFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBlendFactorFB srcFactorColor; + XrBlendFactorFB dstFactorColor; + XrBlendFactorFB srcFactorAlpha; + XrBlendFactorFB dstFactorAlpha; +} XrCompositionLayerAlphaBlendFB; + + + +#define XR_MND_headless 1 +#define XR_MND_headless_SPEC_VERSION 2 +#define XR_MND_HEADLESS_EXTENSION_NAME "XR_MND_headless" + + +#define XR_OCULUS_android_session_state_enable 1 +#define XR_OCULUS_android_session_state_enable_SPEC_VERSION 1 +#define XR_OCULUS_ANDROID_SESSION_STATE_ENABLE_EXTENSION_NAME "XR_OCULUS_android_session_state_enable" + + +#define XR_EXT_view_configuration_depth_range 1 +#define XR_EXT_view_configuration_depth_range_SPEC_VERSION 1 +#define XR_EXT_VIEW_CONFIGURATION_DEPTH_RANGE_EXTENSION_NAME "XR_EXT_view_configuration_depth_range" +// XrViewConfigurationDepthRangeEXT extends XrViewConfigurationView +typedef struct XrViewConfigurationDepthRangeEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + float recommendedNearZ; + float minNearZ; + float recommendedFarZ; + float maxFarZ; +} XrViewConfigurationDepthRangeEXT; + + + +#define XR_EXT_conformance_automation 1 +#define XR_EXT_conformance_automation_SPEC_VERSION 3 +#define XR_EXT_CONFORMANCE_AUTOMATION_EXTENSION_NAME "XR_EXT_conformance_automation" +typedef XrResult (XRAPI_PTR *PFN_xrSetInputDeviceActiveEXT)(XrSession session, XrPath interactionProfile, XrPath topLevelPath, XrBool32 isActive); +typedef XrResult (XRAPI_PTR *PFN_xrSetInputDeviceStateBoolEXT)(XrSession session, XrPath topLevelPath, XrPath inputSourcePath, XrBool32 state); +typedef XrResult (XRAPI_PTR *PFN_xrSetInputDeviceStateFloatEXT)(XrSession session, XrPath topLevelPath, XrPath inputSourcePath, float state); +typedef XrResult (XRAPI_PTR *PFN_xrSetInputDeviceStateVector2fEXT)(XrSession session, XrPath topLevelPath, XrPath inputSourcePath, XrVector2f state); +typedef XrResult (XRAPI_PTR *PFN_xrSetInputDeviceLocationEXT)(XrSession session, XrPath topLevelPath, XrPath inputSourcePath, XrSpace space, XrPosef pose); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrSetInputDeviceActiveEXT( + XrSession session, + XrPath interactionProfile, + XrPath topLevelPath, + XrBool32 isActive); + +XRAPI_ATTR XrResult XRAPI_CALL xrSetInputDeviceStateBoolEXT( + XrSession session, + XrPath topLevelPath, + XrPath inputSourcePath, + XrBool32 state); + +XRAPI_ATTR XrResult XRAPI_CALL xrSetInputDeviceStateFloatEXT( + XrSession session, + XrPath topLevelPath, + XrPath inputSourcePath, + float state); + +XRAPI_ATTR XrResult XRAPI_CALL xrSetInputDeviceStateVector2fEXT( + XrSession session, + XrPath topLevelPath, + XrPath inputSourcePath, + XrVector2f state); + +XRAPI_ATTR XrResult XRAPI_CALL xrSetInputDeviceLocationEXT( + XrSession session, + XrPath topLevelPath, + XrPath inputSourcePath, + XrSpace space, + XrPosef pose); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +#define XR_MSFT_spatial_graph_bridge 1 +#define XR_MSFT_spatial_graph_bridge_SPEC_VERSION 1 +#define XR_MSFT_SPATIAL_GRAPH_BRIDGE_EXTENSION_NAME "XR_MSFT_spatial_graph_bridge" + +typedef enum XrSpatialGraphNodeTypeMSFT { + XR_SPATIAL_GRAPH_NODE_TYPE_STATIC_MSFT = 1, + XR_SPATIAL_GRAPH_NODE_TYPE_DYNAMIC_MSFT = 2, + XR_SPATIAL_GRAPH_NODE_TYPE_MAX_ENUM_MSFT = 0x7FFFFFFF +} XrSpatialGraphNodeTypeMSFT; +typedef struct XrSpatialGraphNodeSpaceCreateInfoMSFT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpatialGraphNodeTypeMSFT nodeType; + uint8_t nodeId[16]; + XrPosef pose; +} XrSpatialGraphNodeSpaceCreateInfoMSFT; + +typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialGraphNodeSpaceMSFT)(XrSession session, const XrSpatialGraphNodeSpaceCreateInfoMSFT* createInfo, XrSpace* space); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialGraphNodeSpaceMSFT( + XrSession session, + const XrSpatialGraphNodeSpaceCreateInfoMSFT* createInfo, + XrSpace* space); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +#define XR_MSFT_hand_interaction 1 +#define XR_MSFT_hand_interaction_SPEC_VERSION 1 +#define XR_MSFT_HAND_INTERACTION_EXTENSION_NAME "XR_MSFT_hand_interaction" + + +#define XR_EXT_hand_tracking 1 + +#define XR_HAND_JOINT_COUNT_EXT 26 + +XR_DEFINE_HANDLE(XrHandTrackerEXT) +#define XR_EXT_hand_tracking_SPEC_VERSION 4 +#define XR_EXT_HAND_TRACKING_EXTENSION_NAME "XR_EXT_hand_tracking" + +typedef enum XrHandEXT { + XR_HAND_LEFT_EXT = 1, + XR_HAND_RIGHT_EXT = 2, + XR_HAND_MAX_ENUM_EXT = 0x7FFFFFFF +} XrHandEXT; + +typedef enum XrHandJointEXT { + XR_HAND_JOINT_PALM_EXT = 0, + XR_HAND_JOINT_WRIST_EXT = 1, + XR_HAND_JOINT_THUMB_METACARPAL_EXT = 2, + XR_HAND_JOINT_THUMB_PROXIMAL_EXT = 3, + XR_HAND_JOINT_THUMB_DISTAL_EXT = 4, + XR_HAND_JOINT_THUMB_TIP_EXT = 5, + XR_HAND_JOINT_INDEX_METACARPAL_EXT = 6, + XR_HAND_JOINT_INDEX_PROXIMAL_EXT = 7, + XR_HAND_JOINT_INDEX_INTERMEDIATE_EXT = 8, + XR_HAND_JOINT_INDEX_DISTAL_EXT = 9, + XR_HAND_JOINT_INDEX_TIP_EXT = 10, + XR_HAND_JOINT_MIDDLE_METACARPAL_EXT = 11, + XR_HAND_JOINT_MIDDLE_PROXIMAL_EXT = 12, + XR_HAND_JOINT_MIDDLE_INTERMEDIATE_EXT = 13, + XR_HAND_JOINT_MIDDLE_DISTAL_EXT = 14, + XR_HAND_JOINT_MIDDLE_TIP_EXT = 15, + XR_HAND_JOINT_RING_METACARPAL_EXT = 16, + XR_HAND_JOINT_RING_PROXIMAL_EXT = 17, + XR_HAND_JOINT_RING_INTERMEDIATE_EXT = 18, + XR_HAND_JOINT_RING_DISTAL_EXT = 19, + XR_HAND_JOINT_RING_TIP_EXT = 20, + XR_HAND_JOINT_LITTLE_METACARPAL_EXT = 21, + XR_HAND_JOINT_LITTLE_PROXIMAL_EXT = 22, + XR_HAND_JOINT_LITTLE_INTERMEDIATE_EXT = 23, + XR_HAND_JOINT_LITTLE_DISTAL_EXT = 24, + XR_HAND_JOINT_LITTLE_TIP_EXT = 25, + XR_HAND_JOINT_MAX_ENUM_EXT = 0x7FFFFFFF +} XrHandJointEXT; + +typedef enum XrHandJointSetEXT { + XR_HAND_JOINT_SET_DEFAULT_EXT = 0, + XR_HAND_JOINT_SET_MAX_ENUM_EXT = 0x7FFFFFFF +} XrHandJointSetEXT; +// XrSystemHandTrackingPropertiesEXT extends XrSystemProperties +typedef struct XrSystemHandTrackingPropertiesEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsHandTracking; +} XrSystemHandTrackingPropertiesEXT; + +typedef struct XrHandTrackerCreateInfoEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrHandEXT hand; + XrHandJointSetEXT handJointSet; +} XrHandTrackerCreateInfoEXT; + +typedef struct XrHandJointsLocateInfoEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpace baseSpace; + XrTime time; +} XrHandJointsLocateInfoEXT; + +typedef struct XrHandJointLocationEXT { + XrSpaceLocationFlags locationFlags; + XrPosef pose; + float radius; +} XrHandJointLocationEXT; + +typedef struct XrHandJointVelocityEXT { + XrSpaceVelocityFlags velocityFlags; + XrVector3f linearVelocity; + XrVector3f angularVelocity; +} XrHandJointVelocityEXT; + +typedef struct XrHandJointLocationsEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 isActive; + uint32_t jointCount; + XrHandJointLocationEXT* jointLocations; +} XrHandJointLocationsEXT; + +// XrHandJointVelocitiesEXT extends XrHandJointLocationsEXT +typedef struct XrHandJointVelocitiesEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t jointCount; + XrHandJointVelocityEXT* jointVelocities; +} XrHandJointVelocitiesEXT; + +typedef XrResult (XRAPI_PTR *PFN_xrCreateHandTrackerEXT)(XrSession session, const XrHandTrackerCreateInfoEXT* createInfo, XrHandTrackerEXT* handTracker); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyHandTrackerEXT)(XrHandTrackerEXT handTracker); +typedef XrResult (XRAPI_PTR *PFN_xrLocateHandJointsEXT)(XrHandTrackerEXT handTracker, const XrHandJointsLocateInfoEXT* locateInfo, XrHandJointLocationsEXT* locations); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreateHandTrackerEXT( + XrSession session, + const XrHandTrackerCreateInfoEXT* createInfo, + XrHandTrackerEXT* handTracker); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyHandTrackerEXT( + XrHandTrackerEXT handTracker); + +XRAPI_ATTR XrResult XRAPI_CALL xrLocateHandJointsEXT( + XrHandTrackerEXT handTracker, + const XrHandJointsLocateInfoEXT* locateInfo, + XrHandJointLocationsEXT* locations); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +#define XR_MSFT_hand_tracking_mesh 1 +#define XR_MSFT_hand_tracking_mesh_SPEC_VERSION 4 +#define XR_MSFT_HAND_TRACKING_MESH_EXTENSION_NAME "XR_MSFT_hand_tracking_mesh" + +typedef enum XrHandPoseTypeMSFT { + XR_HAND_POSE_TYPE_TRACKED_MSFT = 0, + XR_HAND_POSE_TYPE_REFERENCE_OPEN_PALM_MSFT = 1, + XR_HAND_POSE_TYPE_MAX_ENUM_MSFT = 0x7FFFFFFF +} XrHandPoseTypeMSFT; +// XrSystemHandTrackingMeshPropertiesMSFT extends XrSystemProperties +typedef struct XrSystemHandTrackingMeshPropertiesMSFT { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsHandTrackingMesh; + uint32_t maxHandMeshIndexCount; + uint32_t maxHandMeshVertexCount; +} XrSystemHandTrackingMeshPropertiesMSFT; + +typedef struct XrHandMeshSpaceCreateInfoMSFT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrHandPoseTypeMSFT handPoseType; + XrPosef poseInHandMeshSpace; +} XrHandMeshSpaceCreateInfoMSFT; + +typedef struct XrHandMeshUpdateInfoMSFT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrTime time; + XrHandPoseTypeMSFT handPoseType; +} XrHandMeshUpdateInfoMSFT; + +typedef struct XrHandMeshIndexBufferMSFT { + uint32_t indexBufferKey; + uint32_t indexCapacityInput; + uint32_t indexCountOutput; + uint32_t* indices; +} XrHandMeshIndexBufferMSFT; + +typedef struct XrHandMeshVertexMSFT { + XrVector3f position; + XrVector3f normal; +} XrHandMeshVertexMSFT; + +typedef struct XrHandMeshVertexBufferMSFT { + XrTime vertexUpdateTime; + uint32_t vertexCapacityInput; + uint32_t vertexCountOutput; + XrHandMeshVertexMSFT* vertices; +} XrHandMeshVertexBufferMSFT; + +typedef struct XrHandMeshMSFT { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 isActive; + XrBool32 indexBufferChanged; + XrBool32 vertexBufferChanged; + XrHandMeshIndexBufferMSFT indexBuffer; + XrHandMeshVertexBufferMSFT vertexBuffer; +} XrHandMeshMSFT; + +// XrHandPoseTypeInfoMSFT extends XrHandTrackerCreateInfoEXT +typedef struct XrHandPoseTypeInfoMSFT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrHandPoseTypeMSFT handPoseType; +} XrHandPoseTypeInfoMSFT; + +typedef XrResult (XRAPI_PTR *PFN_xrCreateHandMeshSpaceMSFT)(XrHandTrackerEXT handTracker, const XrHandMeshSpaceCreateInfoMSFT* createInfo, XrSpace* space); +typedef XrResult (XRAPI_PTR *PFN_xrUpdateHandMeshMSFT)(XrHandTrackerEXT handTracker, const XrHandMeshUpdateInfoMSFT* updateInfo, XrHandMeshMSFT* handMesh); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreateHandMeshSpaceMSFT( + XrHandTrackerEXT handTracker, + const XrHandMeshSpaceCreateInfoMSFT* createInfo, + XrSpace* space); + +XRAPI_ATTR XrResult XRAPI_CALL xrUpdateHandMeshMSFT( + XrHandTrackerEXT handTracker, + const XrHandMeshUpdateInfoMSFT* updateInfo, + XrHandMeshMSFT* handMesh); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +#define XR_MSFT_secondary_view_configuration 1 +#define XR_MSFT_secondary_view_configuration_SPEC_VERSION 1 +#define XR_MSFT_SECONDARY_VIEW_CONFIGURATION_EXTENSION_NAME "XR_MSFT_secondary_view_configuration" +// XrSecondaryViewConfigurationSessionBeginInfoMSFT extends XrSessionBeginInfo +typedef struct XrSecondaryViewConfigurationSessionBeginInfoMSFT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t viewConfigurationCount; + const XrViewConfigurationType* enabledViewConfigurationTypes; +} XrSecondaryViewConfigurationSessionBeginInfoMSFT; + +typedef struct XrSecondaryViewConfigurationStateMSFT { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrViewConfigurationType viewConfigurationType; + XrBool32 active; +} XrSecondaryViewConfigurationStateMSFT; + +// XrSecondaryViewConfigurationFrameStateMSFT extends XrFrameState +typedef struct XrSecondaryViewConfigurationFrameStateMSFT { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t viewConfigurationCount; + XrSecondaryViewConfigurationStateMSFT* viewConfigurationStates; +} XrSecondaryViewConfigurationFrameStateMSFT; + +typedef struct XrSecondaryViewConfigurationLayerInfoMSFT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrViewConfigurationType viewConfigurationType; + XrEnvironmentBlendMode environmentBlendMode; + uint32_t layerCount; + const XrCompositionLayerBaseHeader* const* layers; +} XrSecondaryViewConfigurationLayerInfoMSFT; + +// XrSecondaryViewConfigurationFrameEndInfoMSFT extends XrFrameEndInfo +typedef struct XrSecondaryViewConfigurationFrameEndInfoMSFT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t viewConfigurationCount; + const XrSecondaryViewConfigurationLayerInfoMSFT* viewConfigurationLayersInfo; +} XrSecondaryViewConfigurationFrameEndInfoMSFT; + +// XrSecondaryViewConfigurationSwapchainCreateInfoMSFT extends XrSwapchainCreateInfo +typedef struct XrSecondaryViewConfigurationSwapchainCreateInfoMSFT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrViewConfigurationType viewConfigurationType; +} XrSecondaryViewConfigurationSwapchainCreateInfoMSFT; + + + +#define XR_MSFT_first_person_observer 1 +#define XR_MSFT_first_person_observer_SPEC_VERSION 1 +#define XR_MSFT_FIRST_PERSON_OBSERVER_EXTENSION_NAME "XR_MSFT_first_person_observer" + + +#define XR_MSFT_controller_model 1 + +#define XR_NULL_CONTROLLER_MODEL_KEY_MSFT 0 + +XR_DEFINE_ATOM(XrControllerModelKeyMSFT) +#define XR_MSFT_controller_model_SPEC_VERSION 2 +#define XR_MSFT_CONTROLLER_MODEL_EXTENSION_NAME "XR_MSFT_controller_model" +#define XR_MAX_CONTROLLER_MODEL_NODE_NAME_SIZE_MSFT 64 +typedef struct XrControllerModelKeyStateMSFT { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrControllerModelKeyMSFT modelKey; +} XrControllerModelKeyStateMSFT; + +typedef struct XrControllerModelNodePropertiesMSFT { + XrStructureType type; + void* XR_MAY_ALIAS next; + char parentNodeName[XR_MAX_CONTROLLER_MODEL_NODE_NAME_SIZE_MSFT]; + char nodeName[XR_MAX_CONTROLLER_MODEL_NODE_NAME_SIZE_MSFT]; +} XrControllerModelNodePropertiesMSFT; + +typedef struct XrControllerModelPropertiesMSFT { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t nodeCapacityInput; + uint32_t nodeCountOutput; + XrControllerModelNodePropertiesMSFT* nodeProperties; +} XrControllerModelPropertiesMSFT; + +typedef struct XrControllerModelNodeStateMSFT { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrPosef nodePose; +} XrControllerModelNodeStateMSFT; + +typedef struct XrControllerModelStateMSFT { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t nodeCapacityInput; + uint32_t nodeCountOutput; + XrControllerModelNodeStateMSFT* nodeStates; +} XrControllerModelStateMSFT; + +typedef XrResult (XRAPI_PTR *PFN_xrGetControllerModelKeyMSFT)(XrSession session, XrPath topLevelUserPath, XrControllerModelKeyStateMSFT* controllerModelKeyState); +typedef XrResult (XRAPI_PTR *PFN_xrLoadControllerModelMSFT)(XrSession session, XrControllerModelKeyMSFT modelKey, uint32_t bufferCapacityInput, uint32_t* bufferCountOutput, uint8_t* buffer); +typedef XrResult (XRAPI_PTR *PFN_xrGetControllerModelPropertiesMSFT)(XrSession session, XrControllerModelKeyMSFT modelKey, XrControllerModelPropertiesMSFT* properties); +typedef XrResult (XRAPI_PTR *PFN_xrGetControllerModelStateMSFT)(XrSession session, XrControllerModelKeyMSFT modelKey, XrControllerModelStateMSFT* state); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrGetControllerModelKeyMSFT( + XrSession session, + XrPath topLevelUserPath, + XrControllerModelKeyStateMSFT* controllerModelKeyState); + +XRAPI_ATTR XrResult XRAPI_CALL xrLoadControllerModelMSFT( + XrSession session, + XrControllerModelKeyMSFT modelKey, + uint32_t bufferCapacityInput, + uint32_t* bufferCountOutput, + uint8_t* buffer); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetControllerModelPropertiesMSFT( + XrSession session, + XrControllerModelKeyMSFT modelKey, + XrControllerModelPropertiesMSFT* properties); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetControllerModelStateMSFT( + XrSession session, + XrControllerModelKeyMSFT modelKey, + XrControllerModelStateMSFT* state); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +#define XR_EXT_win32_appcontainer_compatible 1 +#define XR_EXT_win32_appcontainer_compatible_SPEC_VERSION 1 +#define XR_EXT_WIN32_APPCONTAINER_COMPATIBLE_EXTENSION_NAME "XR_EXT_win32_appcontainer_compatible" + + +#define XR_EPIC_view_configuration_fov 1 +#define XR_EPIC_view_configuration_fov_SPEC_VERSION 2 +#define XR_EPIC_VIEW_CONFIGURATION_FOV_EXTENSION_NAME "XR_EPIC_view_configuration_fov" +// XrViewConfigurationViewFovEPIC extends XrViewConfigurationView +typedef struct XrViewConfigurationViewFovEPIC { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrFovf recommendedFov; + XrFovf maxMutableFov; +} XrViewConfigurationViewFovEPIC; + + + +#define XR_MSFT_composition_layer_reprojection 1 +#define XR_MSFT_composition_layer_reprojection_SPEC_VERSION 1 +#define XR_MSFT_COMPOSITION_LAYER_REPROJECTION_EXTENSION_NAME "XR_MSFT_composition_layer_reprojection" + +typedef enum XrReprojectionModeMSFT { + XR_REPROJECTION_MODE_DEPTH_MSFT = 1, + XR_REPROJECTION_MODE_PLANAR_FROM_DEPTH_MSFT = 2, + XR_REPROJECTION_MODE_PLANAR_MANUAL_MSFT = 3, + XR_REPROJECTION_MODE_ORIENTATION_ONLY_MSFT = 4, + XR_REPROJECTION_MODE_MAX_ENUM_MSFT = 0x7FFFFFFF +} XrReprojectionModeMSFT; +// XrCompositionLayerReprojectionInfoMSFT extends XrCompositionLayerProjection +typedef struct XrCompositionLayerReprojectionInfoMSFT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrReprojectionModeMSFT reprojectionMode; +} XrCompositionLayerReprojectionInfoMSFT; + +// XrCompositionLayerReprojectionPlaneOverrideMSFT extends XrCompositionLayerProjection +typedef struct XrCompositionLayerReprojectionPlaneOverrideMSFT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrVector3f position; + XrVector3f normal; + XrVector3f velocity; +} XrCompositionLayerReprojectionPlaneOverrideMSFT; + +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateReprojectionModesMSFT)(XrInstance instance, XrSystemId systemId, XrViewConfigurationType viewConfigurationType, uint32_t modeCapacityInput, uint32_t* modeCountOutput, XrReprojectionModeMSFT* modes); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateReprojectionModesMSFT( + XrInstance instance, + XrSystemId systemId, + XrViewConfigurationType viewConfigurationType, + uint32_t modeCapacityInput, + uint32_t* modeCountOutput, + XrReprojectionModeMSFT* modes); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +#define XR_HUAWEI_controller_interaction 1 +#define XR_HUAWEI_controller_interaction_SPEC_VERSION 1 +#define XR_HUAWEI_CONTROLLER_INTERACTION_EXTENSION_NAME "XR_HUAWEI_controller_interaction" + + +#define XR_FB_swapchain_update_state 1 +#define XR_FB_swapchain_update_state_SPEC_VERSION 3 +#define XR_FB_SWAPCHAIN_UPDATE_STATE_EXTENSION_NAME "XR_FB_swapchain_update_state" +typedef struct XR_MAY_ALIAS XrSwapchainStateBaseHeaderFB { + XrStructureType type; + void* XR_MAY_ALIAS next; +} XrSwapchainStateBaseHeaderFB; + +typedef XrResult (XRAPI_PTR *PFN_xrUpdateSwapchainFB)(XrSwapchain swapchain, const XrSwapchainStateBaseHeaderFB* state); +typedef XrResult (XRAPI_PTR *PFN_xrGetSwapchainStateFB)(XrSwapchain swapchain, XrSwapchainStateBaseHeaderFB* state); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrUpdateSwapchainFB( + XrSwapchain swapchain, + const XrSwapchainStateBaseHeaderFB* state); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetSwapchainStateFB( + XrSwapchain swapchain, + XrSwapchainStateBaseHeaderFB* state); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +#define XR_FB_composition_layer_secure_content 1 +#define XR_FB_composition_layer_secure_content_SPEC_VERSION 1 +#define XR_FB_COMPOSITION_LAYER_SECURE_CONTENT_EXTENSION_NAME "XR_FB_composition_layer_secure_content" +typedef XrFlags64 XrCompositionLayerSecureContentFlagsFB; + +// Flag bits for XrCompositionLayerSecureContentFlagsFB +static const XrCompositionLayerSecureContentFlagsFB XR_COMPOSITION_LAYER_SECURE_CONTENT_EXCLUDE_LAYER_BIT_FB = 0x00000001; +static const XrCompositionLayerSecureContentFlagsFB XR_COMPOSITION_LAYER_SECURE_CONTENT_REPLACE_LAYER_BIT_FB = 0x00000002; + +// XrCompositionLayerSecureContentFB extends XrCompositionLayerBaseHeader +typedef struct XrCompositionLayerSecureContentFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrCompositionLayerSecureContentFlagsFB flags; +} XrCompositionLayerSecureContentFB; + + + +#define XR_VALVE_analog_threshold 1 +#define XR_VALVE_analog_threshold_SPEC_VERSION 2 +#define XR_VALVE_ANALOG_THRESHOLD_EXTENSION_NAME "XR_VALVE_analog_threshold" +typedef struct XrInteractionProfileAnalogThresholdVALVE { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrAction action; + XrPath binding; + float onThreshold; + float offThreshold; + const XrHapticBaseHeader* onHaptic; + const XrHapticBaseHeader* offHaptic; +} XrInteractionProfileAnalogThresholdVALVE; + + + +#define XR_EXT_hand_joints_motion_range 1 +#define XR_EXT_hand_joints_motion_range_SPEC_VERSION 1 +#define XR_EXT_HAND_JOINTS_MOTION_RANGE_EXTENSION_NAME "XR_EXT_hand_joints_motion_range" + +typedef enum XrHandJointsMotionRangeEXT { + XR_HAND_JOINTS_MOTION_RANGE_UNOBSTRUCTED_EXT = 1, + XR_HAND_JOINTS_MOTION_RANGE_CONFORMING_TO_CONTROLLER_EXT = 2, + XR_HAND_JOINTS_MOTION_RANGE_MAX_ENUM_EXT = 0x7FFFFFFF +} XrHandJointsMotionRangeEXT; +// XrHandJointsMotionRangeInfoEXT extends XrHandJointsLocateInfoEXT +typedef struct XrHandJointsMotionRangeInfoEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrHandJointsMotionRangeEXT handJointsMotionRange; +} XrHandJointsMotionRangeInfoEXT; + + + +#define XR_EXT_samsung_odyssey_controller 1 +#define XR_EXT_samsung_odyssey_controller_SPEC_VERSION 1 +#define XR_EXT_SAMSUNG_ODYSSEY_CONTROLLER_EXTENSION_NAME "XR_EXT_samsung_odyssey_controller" + + +#define XR_EXT_hp_mixed_reality_controller 1 +#define XR_EXT_hp_mixed_reality_controller_SPEC_VERSION 1 +#define XR_EXT_HP_MIXED_REALITY_CONTROLLER_EXTENSION_NAME "XR_EXT_hp_mixed_reality_controller" + + +#define XR_MND_swapchain_usage_input_attachment_bit 1 +#define XR_MND_swapchain_usage_input_attachment_bit_SPEC_VERSION 2 +#define XR_MND_SWAPCHAIN_USAGE_INPUT_ATTACHMENT_BIT_EXTENSION_NAME "XR_MND_swapchain_usage_input_attachment_bit" + + +#define XR_MSFT_scene_understanding 1 + + XR_DEFINE_HANDLE(XrSceneObserverMSFT) + + + XR_DEFINE_HANDLE(XrSceneMSFT) + +#define XR_MSFT_scene_understanding_SPEC_VERSION 1 +#define XR_MSFT_SCENE_UNDERSTANDING_EXTENSION_NAME "XR_MSFT_scene_understanding" + +typedef enum XrSceneComputeFeatureMSFT { + XR_SCENE_COMPUTE_FEATURE_PLANE_MSFT = 1, + XR_SCENE_COMPUTE_FEATURE_PLANE_MESH_MSFT = 2, + XR_SCENE_COMPUTE_FEATURE_VISUAL_MESH_MSFT = 3, + XR_SCENE_COMPUTE_FEATURE_COLLIDER_MESH_MSFT = 4, + XR_SCENE_COMPUTE_FEATURE_SERIALIZE_SCENE_MSFT = 1000098000, + XR_SCENE_COMPUTE_FEATURE_MAX_ENUM_MSFT = 0x7FFFFFFF +} XrSceneComputeFeatureMSFT; + +typedef enum XrSceneComputeConsistencyMSFT { + XR_SCENE_COMPUTE_CONSISTENCY_SNAPSHOT_COMPLETE_MSFT = 1, + XR_SCENE_COMPUTE_CONSISTENCY_SNAPSHOT_INCOMPLETE_FAST_MSFT = 2, + XR_SCENE_COMPUTE_CONSISTENCY_OCCLUSION_OPTIMIZED_MSFT = 3, + XR_SCENE_COMPUTE_CONSISTENCY_MAX_ENUM_MSFT = 0x7FFFFFFF +} XrSceneComputeConsistencyMSFT; + +typedef enum XrMeshComputeLodMSFT { + XR_MESH_COMPUTE_LOD_COARSE_MSFT = 1, + XR_MESH_COMPUTE_LOD_MEDIUM_MSFT = 2, + XR_MESH_COMPUTE_LOD_FINE_MSFT = 3, + XR_MESH_COMPUTE_LOD_UNLIMITED_MSFT = 4, + XR_MESH_COMPUTE_LOD_MAX_ENUM_MSFT = 0x7FFFFFFF +} XrMeshComputeLodMSFT; + +typedef enum XrSceneComponentTypeMSFT { + XR_SCENE_COMPONENT_TYPE_INVALID_MSFT = -1, + XR_SCENE_COMPONENT_TYPE_OBJECT_MSFT = 1, + XR_SCENE_COMPONENT_TYPE_PLANE_MSFT = 2, + XR_SCENE_COMPONENT_TYPE_VISUAL_MESH_MSFT = 3, + XR_SCENE_COMPONENT_TYPE_COLLIDER_MESH_MSFT = 4, + XR_SCENE_COMPONENT_TYPE_SERIALIZED_SCENE_FRAGMENT_MSFT = 1000098000, + XR_SCENE_COMPONENT_TYPE_MAX_ENUM_MSFT = 0x7FFFFFFF +} XrSceneComponentTypeMSFT; + +typedef enum XrSceneObjectTypeMSFT { + XR_SCENE_OBJECT_TYPE_UNCATEGORIZED_MSFT = -1, + XR_SCENE_OBJECT_TYPE_BACKGROUND_MSFT = 1, + XR_SCENE_OBJECT_TYPE_WALL_MSFT = 2, + XR_SCENE_OBJECT_TYPE_FLOOR_MSFT = 3, + XR_SCENE_OBJECT_TYPE_CEILING_MSFT = 4, + XR_SCENE_OBJECT_TYPE_PLATFORM_MSFT = 5, + XR_SCENE_OBJECT_TYPE_INFERRED_MSFT = 6, + XR_SCENE_OBJECT_TYPE_MAX_ENUM_MSFT = 0x7FFFFFFF +} XrSceneObjectTypeMSFT; + +typedef enum XrScenePlaneAlignmentTypeMSFT { + XR_SCENE_PLANE_ALIGNMENT_TYPE_NON_ORTHOGONAL_MSFT = 0, + XR_SCENE_PLANE_ALIGNMENT_TYPE_HORIZONTAL_MSFT = 1, + XR_SCENE_PLANE_ALIGNMENT_TYPE_VERTICAL_MSFT = 2, + XR_SCENE_PLANE_ALIGNMENT_TYPE_MAX_ENUM_MSFT = 0x7FFFFFFF +} XrScenePlaneAlignmentTypeMSFT; + +typedef enum XrSceneComputeStateMSFT { + XR_SCENE_COMPUTE_STATE_NONE_MSFT = 0, + XR_SCENE_COMPUTE_STATE_UPDATING_MSFT = 1, + XR_SCENE_COMPUTE_STATE_COMPLETED_MSFT = 2, + XR_SCENE_COMPUTE_STATE_COMPLETED_WITH_ERROR_MSFT = 3, + XR_SCENE_COMPUTE_STATE_MAX_ENUM_MSFT = 0x7FFFFFFF +} XrSceneComputeStateMSFT; +typedef struct XrUuidMSFT { + uint8_t bytes[16]; +} XrUuidMSFT; + +typedef struct XrSceneObserverCreateInfoMSFT { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrSceneObserverCreateInfoMSFT; + +typedef struct XrSceneCreateInfoMSFT { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrSceneCreateInfoMSFT; + +typedef struct XrSceneSphereBoundMSFT { + XrVector3f center; + float radius; +} XrSceneSphereBoundMSFT; + +typedef struct XrSceneOrientedBoxBoundMSFT { + XrPosef pose; + XrVector3f extents; +} XrSceneOrientedBoxBoundMSFT; + +typedef struct XrSceneFrustumBoundMSFT { + XrPosef pose; + XrFovf fov; + float farDistance; +} XrSceneFrustumBoundMSFT; + +typedef struct XrSceneBoundsMSFT { + XrSpace space; + XrTime time; + uint32_t sphereCount; + const XrSceneSphereBoundMSFT* spheres; + uint32_t boxCount; + const XrSceneOrientedBoxBoundMSFT* boxes; + uint32_t frustumCount; + const XrSceneFrustumBoundMSFT* frustums; +} XrSceneBoundsMSFT; + +typedef struct XrNewSceneComputeInfoMSFT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t requestedFeatureCount; + const XrSceneComputeFeatureMSFT* requestedFeatures; + XrSceneComputeConsistencyMSFT consistency; + XrSceneBoundsMSFT bounds; +} XrNewSceneComputeInfoMSFT; + +// XrVisualMeshComputeLodInfoMSFT extends XrNewSceneComputeInfoMSFT +typedef struct XrVisualMeshComputeLodInfoMSFT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrMeshComputeLodMSFT lod; +} XrVisualMeshComputeLodInfoMSFT; + +typedef struct XrSceneComponentMSFT { + XrSceneComponentTypeMSFT componentType; + XrUuidMSFT id; + XrUuidMSFT parentId; + XrTime updateTime; +} XrSceneComponentMSFT; + +typedef struct XrSceneComponentsMSFT { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t componentCapacityInput; + uint32_t componentCountOutput; + XrSceneComponentMSFT* components; +} XrSceneComponentsMSFT; + +typedef struct XrSceneComponentsGetInfoMSFT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSceneComponentTypeMSFT componentType; +} XrSceneComponentsGetInfoMSFT; + +typedef struct XrSceneComponentLocationMSFT { + XrSpaceLocationFlags flags; + XrPosef pose; +} XrSceneComponentLocationMSFT; + +typedef struct XrSceneComponentLocationsMSFT { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t locationCount; + XrSceneComponentLocationMSFT* locations; +} XrSceneComponentLocationsMSFT; + +typedef struct XrSceneComponentsLocateInfoMSFT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpace baseSpace; + XrTime time; + uint32_t componentIdCount; + const XrUuidMSFT* componentIds; +} XrSceneComponentsLocateInfoMSFT; + +typedef struct XrSceneObjectMSFT { + XrSceneObjectTypeMSFT objectType; +} XrSceneObjectMSFT; + +// XrSceneObjectsMSFT extends XrSceneComponentsMSFT +typedef struct XrSceneObjectsMSFT { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t sceneObjectCount; + XrSceneObjectMSFT* sceneObjects; +} XrSceneObjectsMSFT; + +// XrSceneComponentParentFilterInfoMSFT extends XrSceneComponentsGetInfoMSFT +typedef struct XrSceneComponentParentFilterInfoMSFT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrUuidMSFT parentId; +} XrSceneComponentParentFilterInfoMSFT; + +// XrSceneObjectTypesFilterInfoMSFT extends XrSceneComponentsGetInfoMSFT +typedef struct XrSceneObjectTypesFilterInfoMSFT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t objectTypeCount; + const XrSceneObjectTypeMSFT* objectTypes; +} XrSceneObjectTypesFilterInfoMSFT; + +typedef struct XrScenePlaneMSFT { + XrScenePlaneAlignmentTypeMSFT alignment; + XrExtent2Df size; + uint64_t meshBufferId; + XrBool32 supportsIndicesUint16; +} XrScenePlaneMSFT; + +// XrScenePlanesMSFT extends XrSceneComponentsMSFT +typedef struct XrScenePlanesMSFT { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t scenePlaneCount; + XrScenePlaneMSFT* scenePlanes; +} XrScenePlanesMSFT; + +// XrScenePlaneAlignmentFilterInfoMSFT extends XrSceneComponentsGetInfoMSFT +typedef struct XrScenePlaneAlignmentFilterInfoMSFT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t alignmentCount; + const XrScenePlaneAlignmentTypeMSFT* alignments; +} XrScenePlaneAlignmentFilterInfoMSFT; + +typedef struct XrSceneMeshMSFT { + uint64_t meshBufferId; + XrBool32 supportsIndicesUint16; +} XrSceneMeshMSFT; + +// XrSceneMeshesMSFT extends XrSceneComponentsMSFT +typedef struct XrSceneMeshesMSFT { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t sceneMeshCount; + XrSceneMeshMSFT* sceneMeshes; +} XrSceneMeshesMSFT; + +typedef struct XrSceneMeshBuffersGetInfoMSFT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint64_t meshBufferId; +} XrSceneMeshBuffersGetInfoMSFT; + +typedef struct XrSceneMeshBuffersMSFT { + XrStructureType type; + void* XR_MAY_ALIAS next; +} XrSceneMeshBuffersMSFT; + +typedef struct XrSceneMeshVertexBufferMSFT { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t vertexCapacityInput; + uint32_t vertexCountOutput; + XrVector3f* vertices; +} XrSceneMeshVertexBufferMSFT; + +typedef struct XrSceneMeshIndicesUint32MSFT { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t indexCapacityInput; + uint32_t indexCountOutput; + uint32_t* indices; +} XrSceneMeshIndicesUint32MSFT; + +typedef struct XrSceneMeshIndicesUint16MSFT { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t indexCapacityInput; + uint32_t indexCountOutput; + uint16_t* indices; +} XrSceneMeshIndicesUint16MSFT; + +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSceneComputeFeaturesMSFT)(XrInstance instance, XrSystemId systemId, uint32_t featureCapacityInput, uint32_t* featureCountOutput, XrSceneComputeFeatureMSFT* features); +typedef XrResult (XRAPI_PTR *PFN_xrCreateSceneObserverMSFT)(XrSession session, const XrSceneObserverCreateInfoMSFT* createInfo, XrSceneObserverMSFT* sceneObserver); +typedef XrResult (XRAPI_PTR *PFN_xrDestroySceneObserverMSFT)(XrSceneObserverMSFT sceneObserver); +typedef XrResult (XRAPI_PTR *PFN_xrCreateSceneMSFT)(XrSceneObserverMSFT sceneObserver, const XrSceneCreateInfoMSFT* createInfo, XrSceneMSFT* scene); +typedef XrResult (XRAPI_PTR *PFN_xrDestroySceneMSFT)(XrSceneMSFT scene); +typedef XrResult (XRAPI_PTR *PFN_xrComputeNewSceneMSFT)(XrSceneObserverMSFT sceneObserver, const XrNewSceneComputeInfoMSFT* computeInfo); +typedef XrResult (XRAPI_PTR *PFN_xrGetSceneComputeStateMSFT)(XrSceneObserverMSFT sceneObserver, XrSceneComputeStateMSFT* state); +typedef XrResult (XRAPI_PTR *PFN_xrGetSceneComponentsMSFT)(XrSceneMSFT scene, const XrSceneComponentsGetInfoMSFT* getInfo, XrSceneComponentsMSFT* components); +typedef XrResult (XRAPI_PTR *PFN_xrLocateSceneComponentsMSFT)(XrSceneMSFT scene, const XrSceneComponentsLocateInfoMSFT* locateInfo, XrSceneComponentLocationsMSFT* locations); +typedef XrResult (XRAPI_PTR *PFN_xrGetSceneMeshBuffersMSFT)(XrSceneMSFT scene, const XrSceneMeshBuffersGetInfoMSFT* getInfo, XrSceneMeshBuffersMSFT* buffers); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateSceneComputeFeaturesMSFT( + XrInstance instance, + XrSystemId systemId, + uint32_t featureCapacityInput, + uint32_t* featureCountOutput, + XrSceneComputeFeatureMSFT* features); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSceneObserverMSFT( + XrSession session, + const XrSceneObserverCreateInfoMSFT* createInfo, + XrSceneObserverMSFT* sceneObserver); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroySceneObserverMSFT( + XrSceneObserverMSFT sceneObserver); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSceneMSFT( + XrSceneObserverMSFT sceneObserver, + const XrSceneCreateInfoMSFT* createInfo, + XrSceneMSFT* scene); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroySceneMSFT( + XrSceneMSFT scene); + +XRAPI_ATTR XrResult XRAPI_CALL xrComputeNewSceneMSFT( + XrSceneObserverMSFT sceneObserver, + const XrNewSceneComputeInfoMSFT* computeInfo); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetSceneComputeStateMSFT( + XrSceneObserverMSFT sceneObserver, + XrSceneComputeStateMSFT* state); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetSceneComponentsMSFT( + XrSceneMSFT scene, + const XrSceneComponentsGetInfoMSFT* getInfo, + XrSceneComponentsMSFT* components); + +XRAPI_ATTR XrResult XRAPI_CALL xrLocateSceneComponentsMSFT( + XrSceneMSFT scene, + const XrSceneComponentsLocateInfoMSFT* locateInfo, + XrSceneComponentLocationsMSFT* locations); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetSceneMeshBuffersMSFT( + XrSceneMSFT scene, + const XrSceneMeshBuffersGetInfoMSFT* getInfo, + XrSceneMeshBuffersMSFT* buffers); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +#define XR_MSFT_scene_understanding_serialization 1 +#define XR_MSFT_scene_understanding_serialization_SPEC_VERSION 1 +#define XR_MSFT_SCENE_UNDERSTANDING_SERIALIZATION_EXTENSION_NAME "XR_MSFT_scene_understanding_serialization" +typedef struct XrSerializedSceneFragmentDataGetInfoMSFT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrUuidMSFT sceneFragmentId; +} XrSerializedSceneFragmentDataGetInfoMSFT; + +typedef struct XrDeserializeSceneFragmentMSFT { + uint32_t bufferSize; + const uint8_t* buffer; +} XrDeserializeSceneFragmentMSFT; + +typedef struct XrSceneDeserializeInfoMSFT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t fragmentCount; + const XrDeserializeSceneFragmentMSFT* fragments; +} XrSceneDeserializeInfoMSFT; + +typedef XrResult (XRAPI_PTR *PFN_xrDeserializeSceneMSFT)(XrSceneObserverMSFT sceneObserver, const XrSceneDeserializeInfoMSFT* deserializeInfo); +typedef XrResult (XRAPI_PTR *PFN_xrGetSerializedSceneFragmentDataMSFT)(XrSceneMSFT scene, const XrSerializedSceneFragmentDataGetInfoMSFT* getInfo, uint32_t countInput, uint32_t* readOutput, uint8_t* buffer); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrDeserializeSceneMSFT( + XrSceneObserverMSFT sceneObserver, + const XrSceneDeserializeInfoMSFT* deserializeInfo); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetSerializedSceneFragmentDataMSFT( + XrSceneMSFT scene, + const XrSerializedSceneFragmentDataGetInfoMSFT* getInfo, + uint32_t countInput, + uint32_t* readOutput, + uint8_t* buffer); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +#define XR_FB_display_refresh_rate 1 +#define XR_FB_display_refresh_rate_SPEC_VERSION 1 +#define XR_FB_DISPLAY_REFRESH_RATE_EXTENSION_NAME "XR_FB_display_refresh_rate" +typedef struct XrEventDataDisplayRefreshRateChangedFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + float fromDisplayRefreshRate; + float toDisplayRefreshRate; +} XrEventDataDisplayRefreshRateChangedFB; + +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateDisplayRefreshRatesFB)(XrSession session, uint32_t displayRefreshRateCapacityInput, uint32_t* displayRefreshRateCountOutput, float* displayRefreshRates); +typedef XrResult (XRAPI_PTR *PFN_xrGetDisplayRefreshRateFB)(XrSession session, float* displayRefreshRate); +typedef XrResult (XRAPI_PTR *PFN_xrRequestDisplayRefreshRateFB)(XrSession session, float displayRefreshRate); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateDisplayRefreshRatesFB( + XrSession session, + uint32_t displayRefreshRateCapacityInput, + uint32_t* displayRefreshRateCountOutput, + float* displayRefreshRates); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetDisplayRefreshRateFB( + XrSession session, + float* displayRefreshRate); + +XRAPI_ATTR XrResult XRAPI_CALL xrRequestDisplayRefreshRateFB( + XrSession session, + float displayRefreshRate); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +#define XR_HTC_vive_cosmos_controller_interaction 1 +#define XR_HTC_vive_cosmos_controller_interaction_SPEC_VERSION 1 +#define XR_HTC_VIVE_COSMOS_CONTROLLER_INTERACTION_EXTENSION_NAME "XR_HTC_vive_cosmos_controller_interaction" + + +#define XR_HTCX_vive_tracker_interaction 1 +#define XR_HTCX_vive_tracker_interaction_SPEC_VERSION 1 +#define XR_HTCX_VIVE_TRACKER_INTERACTION_EXTENSION_NAME "XR_HTCX_vive_tracker_interaction" +typedef struct XrViveTrackerPathsHTCX { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrPath persistentPath; + XrPath rolePath; +} XrViveTrackerPathsHTCX; + +typedef struct XrEventDataViveTrackerConnectedHTCX { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrViveTrackerPathsHTCX* paths; +} XrEventDataViveTrackerConnectedHTCX; + +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateViveTrackerPathsHTCX)(XrInstance instance, uint32_t pathCapacityInput, uint32_t* pathCountOutput, XrViveTrackerPathsHTCX* paths); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateViveTrackerPathsHTCX( + XrInstance instance, + uint32_t pathCapacityInput, + uint32_t* pathCountOutput, + XrViveTrackerPathsHTCX* paths); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +#define XR_HTC_facial_tracking 1 + +#define XR_FACIAL_EXPRESSION_EYE_COUNT_HTC 14 + + +#define XR_FACIAL_EXPRESSION_LIP_COUNT_HTC 37 + +XR_DEFINE_HANDLE(XrFacialTrackerHTC) +#define XR_HTC_facial_tracking_SPEC_VERSION 1 +#define XR_HTC_FACIAL_TRACKING_EXTENSION_NAME "XR_HTC_facial_tracking" + +typedef enum XrEyeExpressionHTC { + XR_EYE_EXPRESSION_LEFT_BLINK_HTC = 0, + XR_EYE_EXPRESSION_LEFT_WIDE_HTC = 1, + XR_EYE_EXPRESSION_RIGHT_BLINK_HTC = 2, + XR_EYE_EXPRESSION_RIGHT_WIDE_HTC = 3, + XR_EYE_EXPRESSION_LEFT_SQUEEZE_HTC = 4, + XR_EYE_EXPRESSION_RIGHT_SQUEEZE_HTC = 5, + XR_EYE_EXPRESSION_LEFT_DOWN_HTC = 6, + XR_EYE_EXPRESSION_RIGHT_DOWN_HTC = 7, + XR_EYE_EXPRESSION_LEFT_OUT_HTC = 8, + XR_EYE_EXPRESSION_RIGHT_IN_HTC = 9, + XR_EYE_EXPRESSION_LEFT_IN_HTC = 10, + XR_EYE_EXPRESSION_RIGHT_OUT_HTC = 11, + XR_EYE_EXPRESSION_LEFT_UP_HTC = 12, + XR_EYE_EXPRESSION_RIGHT_UP_HTC = 13, + XR_EYE_EXPRESSION_MAX_ENUM_HTC = 0x7FFFFFFF +} XrEyeExpressionHTC; + +typedef enum XrLipExpressionHTC { + XR_LIP_EXPRESSION_JAW_RIGHT_HTC = 0, + XR_LIP_EXPRESSION_JAW_LEFT_HTC = 1, + XR_LIP_EXPRESSION_JAW_FORWARD_HTC = 2, + XR_LIP_EXPRESSION_JAW_OPEN_HTC = 3, + XR_LIP_EXPRESSION_MOUTH_APE_SHAPE_HTC = 4, + XR_LIP_EXPRESSION_MOUTH_UPPER_RIGHT_HTC = 5, + XR_LIP_EXPRESSION_MOUTH_UPPER_LEFT_HTC = 6, + XR_LIP_EXPRESSION_MOUTH_LOWER_RIGHT_HTC = 7, + XR_LIP_EXPRESSION_MOUTH_LOWER_LEFT_HTC = 8, + XR_LIP_EXPRESSION_MOUTH_UPPER_OVERTURN_HTC = 9, + XR_LIP_EXPRESSION_MOUTH_LOWER_OVERTURN_HTC = 10, + XR_LIP_EXPRESSION_MOUTH_POUT_HTC = 11, + XR_LIP_EXPRESSION_MOUTH_SMILE_RIGHT_HTC = 12, + XR_LIP_EXPRESSION_MOUTH_SMILE_LEFT_HTC = 13, + XR_LIP_EXPRESSION_MOUTH_SAD_RIGHT_HTC = 14, + XR_LIP_EXPRESSION_MOUTH_SAD_LEFT_HTC = 15, + XR_LIP_EXPRESSION_CHEEK_PUFF_RIGHT_HTC = 16, + XR_LIP_EXPRESSION_CHEEK_PUFF_LEFT_HTC = 17, + XR_LIP_EXPRESSION_CHEEK_SUCK_HTC = 18, + XR_LIP_EXPRESSION_MOUTH_UPPER_UPRIGHT_HTC = 19, + XR_LIP_EXPRESSION_MOUTH_UPPER_UPLEFT_HTC = 20, + XR_LIP_EXPRESSION_MOUTH_LOWER_DOWNRIGHT_HTC = 21, + XR_LIP_EXPRESSION_MOUTH_LOWER_DOWNLEFT_HTC = 22, + XR_LIP_EXPRESSION_MOUTH_UPPER_INSIDE_HTC = 23, + XR_LIP_EXPRESSION_MOUTH_LOWER_INSIDE_HTC = 24, + XR_LIP_EXPRESSION_MOUTH_LOWER_OVERLAY_HTC = 25, + XR_LIP_EXPRESSION_TONGUE_LONGSTEP1_HTC = 26, + XR_LIP_EXPRESSION_TONGUE_LEFT_HTC = 27, + XR_LIP_EXPRESSION_TONGUE_RIGHT_HTC = 28, + XR_LIP_EXPRESSION_TONGUE_UP_HTC = 29, + XR_LIP_EXPRESSION_TONGUE_DOWN_HTC = 30, + XR_LIP_EXPRESSION_TONGUE_ROLL_HTC = 31, + XR_LIP_EXPRESSION_TONGUE_LONGSTEP2_HTC = 32, + XR_LIP_EXPRESSION_TONGUE_UPRIGHT_MORPH_HTC = 33, + XR_LIP_EXPRESSION_TONGUE_UPLEFT_MORPH_HTC = 34, + XR_LIP_EXPRESSION_TONGUE_DOWNRIGHT_MORPH_HTC = 35, + XR_LIP_EXPRESSION_TONGUE_DOWNLEFT_MORPH_HTC = 36, + XR_LIP_EXPRESSION_MAX_ENUM_HTC = 0x7FFFFFFF +} XrLipExpressionHTC; + +typedef enum XrFacialTrackingTypeHTC { + XR_FACIAL_TRACKING_TYPE_EYE_DEFAULT_HTC = 1, + XR_FACIAL_TRACKING_TYPE_LIP_DEFAULT_HTC = 2, + XR_FACIAL_TRACKING_TYPE_MAX_ENUM_HTC = 0x7FFFFFFF +} XrFacialTrackingTypeHTC; +// XrSystemFacialTrackingPropertiesHTC extends XrSystemProperties +typedef struct XrSystemFacialTrackingPropertiesHTC { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportEyeFacialTracking; + XrBool32 supportLipFacialTracking; +} XrSystemFacialTrackingPropertiesHTC; + +typedef struct XrFacialExpressionsHTC { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrBool32 isActive; + XrTime sampleTime; + uint32_t expressionCount; + float* expressionWeightings; +} XrFacialExpressionsHTC; + +typedef struct XrFacialTrackerCreateInfoHTC { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrFacialTrackingTypeHTC facialTrackingType; +} XrFacialTrackerCreateInfoHTC; + +typedef XrResult (XRAPI_PTR *PFN_xrCreateFacialTrackerHTC)(XrSession session, const XrFacialTrackerCreateInfoHTC* createInfo, XrFacialTrackerHTC* facialTracker); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyFacialTrackerHTC)(XrFacialTrackerHTC facialTracker); +typedef XrResult (XRAPI_PTR *PFN_xrGetFacialExpressionsHTC)(XrFacialTrackerHTC facialTracker, XrFacialExpressionsHTC* facialExpressions); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreateFacialTrackerHTC( + XrSession session, + const XrFacialTrackerCreateInfoHTC* createInfo, + XrFacialTrackerHTC* facialTracker); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyFacialTrackerHTC( + XrFacialTrackerHTC facialTracker); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetFacialExpressionsHTC( + XrFacialTrackerHTC facialTracker, + XrFacialExpressionsHTC* facialExpressions); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +#define XR_HTC_vive_focus3_controller_interaction 1 +#define XR_HTC_vive_focus3_controller_interaction_SPEC_VERSION 1 +#define XR_HTC_VIVE_FOCUS3_CONTROLLER_INTERACTION_EXTENSION_NAME "XR_HTC_vive_focus3_controller_interaction" + + +#define XR_FB_color_space 1 +#define XR_FB_color_space_SPEC_VERSION 2 +#define XR_FB_COLOR_SPACE_EXTENSION_NAME "XR_FB_color_space" + +typedef enum XrColorSpaceFB { + XR_COLOR_SPACE_UNMANAGED_FB = 0, + XR_COLOR_SPACE_REC2020_FB = 1, + XR_COLOR_SPACE_REC709_FB = 2, + XR_COLOR_SPACE_RIFT_CV1_FB = 3, + XR_COLOR_SPACE_RIFT_S_FB = 4, + XR_COLOR_SPACE_QUEST_FB = 5, + XR_COLOR_SPACE_P3_FB = 6, + XR_COLOR_SPACE_ADOBE_RGB_FB = 7, + XR_COLOR_SPACE_MAX_ENUM_FB = 0x7FFFFFFF +} XrColorSpaceFB; +// XrSystemColorSpacePropertiesFB extends XrSystemProperties +typedef struct XrSystemColorSpacePropertiesFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrColorSpaceFB colorSpace; +} XrSystemColorSpacePropertiesFB; + +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateColorSpacesFB)(XrSession session, uint32_t colorSpaceCapacityInput, uint32_t* colorSpaceCountOutput, XrColorSpaceFB* colorSpaces); +typedef XrResult (XRAPI_PTR *PFN_xrSetColorSpaceFB)(XrSession session, const XrColorSpaceFB colorspace); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateColorSpacesFB( + XrSession session, + uint32_t colorSpaceCapacityInput, + uint32_t* colorSpaceCountOutput, + XrColorSpaceFB* colorSpaces); + +XRAPI_ATTR XrResult XRAPI_CALL xrSetColorSpaceFB( + XrSession session, + const XrColorSpaceFB colorspace); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +#define XR_FB_hand_tracking_mesh 1 +#define XR_FB_hand_tracking_mesh_SPEC_VERSION 1 +#define XR_FB_HAND_TRACKING_MESH_EXTENSION_NAME "XR_FB_hand_tracking_mesh" +typedef struct XrVector4sFB { + int16_t x; + int16_t y; + int16_t z; + int16_t w; +} XrVector4sFB; + +typedef struct XrHandTrackingMeshFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t jointCapacityInput; + uint32_t jointCountOutput; + XrPosef* jointBindPoses; + float* jointRadii; + XrHandJointEXT* jointParents; + uint32_t vertexCapacityInput; + uint32_t vertexCountOutput; + XrVector3f* vertexPositions; + XrVector3f* vertexNormals; + XrVector2f* vertexUVs; + XrVector4sFB* vertexBlendIndices; + XrVector4f* vertexBlendWeights; + uint32_t indexCapacityInput; + uint32_t indexCountOutput; + int16_t* indices; +} XrHandTrackingMeshFB; + +// XrHandTrackingScaleFB extends XrHandJointsLocateInfoEXT +typedef struct XrHandTrackingScaleFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + float sensorOutput; + float currentOutput; + XrBool32 overrideHandScale; + float overrideValueInput; +} XrHandTrackingScaleFB; + +typedef XrResult (XRAPI_PTR *PFN_xrGetHandMeshFB)(XrHandTrackerEXT handTracker, XrHandTrackingMeshFB* mesh); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrGetHandMeshFB( + XrHandTrackerEXT handTracker, + XrHandTrackingMeshFB* mesh); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +#define XR_FB_hand_tracking_aim 1 +#define XR_FB_hand_tracking_aim_SPEC_VERSION 1 +#define XR_FB_HAND_TRACKING_AIM_EXTENSION_NAME "XR_FB_hand_tracking_aim" +typedef XrFlags64 XrHandTrackingAimFlagsFB; + +// Flag bits for XrHandTrackingAimFlagsFB +static const XrHandTrackingAimFlagsFB XR_HAND_TRACKING_AIM_COMPUTED_BIT_FB = 0x00000001; +static const XrHandTrackingAimFlagsFB XR_HAND_TRACKING_AIM_VALID_BIT_FB = 0x00000002; +static const XrHandTrackingAimFlagsFB XR_HAND_TRACKING_AIM_INDEX_PINCHING_BIT_FB = 0x00000004; +static const XrHandTrackingAimFlagsFB XR_HAND_TRACKING_AIM_MIDDLE_PINCHING_BIT_FB = 0x00000008; +static const XrHandTrackingAimFlagsFB XR_HAND_TRACKING_AIM_RING_PINCHING_BIT_FB = 0x00000010; +static const XrHandTrackingAimFlagsFB XR_HAND_TRACKING_AIM_LITTLE_PINCHING_BIT_FB = 0x00000020; +static const XrHandTrackingAimFlagsFB XR_HAND_TRACKING_AIM_SYSTEM_GESTURE_BIT_FB = 0x00000040; +static const XrHandTrackingAimFlagsFB XR_HAND_TRACKING_AIM_DOMINANT_HAND_BIT_FB = 0x00000080; +static const XrHandTrackingAimFlagsFB XR_HAND_TRACKING_AIM_MENU_PRESSED_BIT_FB = 0x00000100; + +// XrHandTrackingAimStateFB extends XrHandJointsLocateInfoEXT +typedef struct XrHandTrackingAimStateFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrHandTrackingAimFlagsFB status; + XrPosef aimPose; + float pinchStrengthIndex; + float pinchStrengthMiddle; + float pinchStrengthRing; + float pinchStrengthLittle; +} XrHandTrackingAimStateFB; + + + +#define XR_FB_hand_tracking_capsules 1 +#define XR_HAND_TRACKING_CAPSULE_POINT_COUNT_FB 2 +#define XR_FB_HAND_TRACKING_CAPSULE_POINT_COUNT XR_HAND_TRACKING_CAPSULE_POINT_COUNT_FB +#define XR_HAND_TRACKING_CAPSULE_COUNT_FB 19 +#define XR_FB_HAND_TRACKING_CAPSULE_COUNT XR_HAND_TRACKING_CAPSULE_COUNT_FB +#define XR_FB_hand_tracking_capsules_SPEC_VERSION 2 +#define XR_FB_HAND_TRACKING_CAPSULES_EXTENSION_NAME "XR_FB_hand_tracking_capsules" +typedef struct XrHandCapsuleFB { + XrVector3f points[XR_FB_HAND_TRACKING_CAPSULE_POINT_COUNT]; + float radius; + XrHandJointEXT joint; +} XrHandCapsuleFB; + +// XrHandTrackingCapsulesStateFB extends XrHandJointsLocateInfoEXT +typedef struct XrHandTrackingCapsulesStateFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrHandCapsuleFB capsules[XR_FB_HAND_TRACKING_CAPSULE_COUNT]; +} XrHandTrackingCapsulesStateFB; + + + +#define XR_FB_foveation 1 +XR_DEFINE_HANDLE(XrFoveationProfileFB) +#define XR_FB_foveation_SPEC_VERSION 1 +#define XR_FB_FOVEATION_EXTENSION_NAME "XR_FB_foveation" +typedef XrFlags64 XrSwapchainCreateFoveationFlagsFB; + +// Flag bits for XrSwapchainCreateFoveationFlagsFB +static const XrSwapchainCreateFoveationFlagsFB XR_SWAPCHAIN_CREATE_FOVEATION_SCALED_BIN_BIT_FB = 0x00000001; +static const XrSwapchainCreateFoveationFlagsFB XR_SWAPCHAIN_CREATE_FOVEATION_FRAGMENT_DENSITY_MAP_BIT_FB = 0x00000002; + +typedef XrFlags64 XrSwapchainStateFoveationFlagsFB; + +// Flag bits for XrSwapchainStateFoveationFlagsFB + +typedef struct XrFoveationProfileCreateInfoFB { + XrStructureType type; + void* XR_MAY_ALIAS next; +} XrFoveationProfileCreateInfoFB; + +// XrSwapchainCreateInfoFoveationFB extends XrSwapchainCreateInfo +typedef struct XrSwapchainCreateInfoFoveationFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrSwapchainCreateFoveationFlagsFB flags; +} XrSwapchainCreateInfoFoveationFB; + +typedef struct XrSwapchainStateFoveationFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrSwapchainStateFoveationFlagsFB flags; + XrFoveationProfileFB profile; +} XrSwapchainStateFoveationFB; + +typedef XrResult (XRAPI_PTR *PFN_xrCreateFoveationProfileFB)(XrSession session, const XrFoveationProfileCreateInfoFB* createInfo, XrFoveationProfileFB* profile); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyFoveationProfileFB)(XrFoveationProfileFB profile); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreateFoveationProfileFB( + XrSession session, + const XrFoveationProfileCreateInfoFB* createInfo, + XrFoveationProfileFB* profile); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyFoveationProfileFB( + XrFoveationProfileFB profile); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +#define XR_FB_foveation_configuration 1 +#define XR_FB_foveation_configuration_SPEC_VERSION 1 +#define XR_FB_FOVEATION_CONFIGURATION_EXTENSION_NAME "XR_FB_foveation_configuration" + +typedef enum XrFoveationLevelFB { + XR_FOVEATION_LEVEL_NONE_FB = 0, + XR_FOVEATION_LEVEL_LOW_FB = 1, + XR_FOVEATION_LEVEL_MEDIUM_FB = 2, + XR_FOVEATION_LEVEL_HIGH_FB = 3, + XR_FOVEATION_LEVEL_MAX_ENUM_FB = 0x7FFFFFFF +} XrFoveationLevelFB; + +typedef enum XrFoveationDynamicFB { + XR_FOVEATION_DYNAMIC_DISABLED_FB = 0, + XR_FOVEATION_DYNAMIC_LEVEL_ENABLED_FB = 1, + XR_FOVEATION_DYNAMIC_MAX_ENUM_FB = 0x7FFFFFFF +} XrFoveationDynamicFB; +// XrFoveationLevelProfileCreateInfoFB extends XrFoveationProfileCreateInfoFB +typedef struct XrFoveationLevelProfileCreateInfoFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrFoveationLevelFB level; + float verticalOffset; + XrFoveationDynamicFB dynamic; +} XrFoveationLevelProfileCreateInfoFB; + + + +#define XR_FB_keyboard_tracking 1 +#define XR_FB_keyboard_tracking_SPEC_VERSION 1 +#define XR_FB_KEYBOARD_TRACKING_EXTENSION_NAME "XR_FB_keyboard_tracking" +#define XR_MAX_KEYBOARD_TRACKING_NAME_SIZE_FB 128 +typedef XrFlags64 XrKeyboardTrackingFlagsFB; + +// Flag bits for XrKeyboardTrackingFlagsFB +static const XrKeyboardTrackingFlagsFB XR_KEYBOARD_TRACKING_EXISTS_BIT_FB = 0x00000001; +static const XrKeyboardTrackingFlagsFB XR_KEYBOARD_TRACKING_LOCAL_BIT_FB = 0x00000002; +static const XrKeyboardTrackingFlagsFB XR_KEYBOARD_TRACKING_REMOTE_BIT_FB = 0x00000004; +static const XrKeyboardTrackingFlagsFB XR_KEYBOARD_TRACKING_CONNECTED_BIT_FB = 0x00000008; + +typedef XrFlags64 XrKeyboardTrackingQueryFlagsFB; + +// Flag bits for XrKeyboardTrackingQueryFlagsFB +static const XrKeyboardTrackingQueryFlagsFB XR_KEYBOARD_TRACKING_QUERY_LOCAL_BIT_FB = 0x00000002; +static const XrKeyboardTrackingQueryFlagsFB XR_KEYBOARD_TRACKING_QUERY_REMOTE_BIT_FB = 0x00000004; + +// XrSystemKeyboardTrackingPropertiesFB extends XrSystemProperties +typedef struct XrSystemKeyboardTrackingPropertiesFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsKeyboardTracking; +} XrSystemKeyboardTrackingPropertiesFB; + +typedef struct XrKeyboardTrackingDescriptionFB { + uint64_t trackedKeyboardId; + XrVector3f size; + XrKeyboardTrackingFlagsFB flags; + char name[XR_MAX_KEYBOARD_TRACKING_NAME_SIZE_FB]; +} XrKeyboardTrackingDescriptionFB; + +typedef struct XrKeyboardSpaceCreateInfoFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint64_t trackedKeyboardId; +} XrKeyboardSpaceCreateInfoFB; + +typedef struct XrKeyboardTrackingQueryFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrKeyboardTrackingQueryFlagsFB flags; +} XrKeyboardTrackingQueryFB; + +typedef XrResult (XRAPI_PTR *PFN_xrQuerySystemTrackedKeyboardFB)(XrSession session, const XrKeyboardTrackingQueryFB* queryInfo, XrKeyboardTrackingDescriptionFB* keyboard); +typedef XrResult (XRAPI_PTR *PFN_xrCreateKeyboardSpaceFB)(XrSession session, const XrKeyboardSpaceCreateInfoFB* createInfo, XrSpace* keyboardSpace); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrQuerySystemTrackedKeyboardFB( + XrSession session, + const XrKeyboardTrackingQueryFB* queryInfo, + XrKeyboardTrackingDescriptionFB* keyboard); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateKeyboardSpaceFB( + XrSession session, + const XrKeyboardSpaceCreateInfoFB* createInfo, + XrSpace* keyboardSpace); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +#define XR_FB_triangle_mesh 1 +XR_DEFINE_HANDLE(XrTriangleMeshFB) +#define XR_FB_triangle_mesh_SPEC_VERSION 1 +#define XR_FB_TRIANGLE_MESH_EXTENSION_NAME "XR_FB_triangle_mesh" + +typedef enum XrWindingOrderFB { + XR_WINDING_ORDER_UNKNOWN_FB = 0, + XR_WINDING_ORDER_CW_FB = 1, + XR_WINDING_ORDER_CCW_FB = 2, + XR_WINDING_ORDER_MAX_ENUM_FB = 0x7FFFFFFF +} XrWindingOrderFB; +typedef XrFlags64 XrTriangleMeshFlagsFB; + +// Flag bits for XrTriangleMeshFlagsFB +static const XrTriangleMeshFlagsFB XR_TRIANGLE_MESH_MUTABLE_BIT_FB = 0x00000001; + +typedef struct XrTriangleMeshCreateInfoFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrTriangleMeshFlagsFB flags; + XrWindingOrderFB windingOrder; + uint32_t vertexCount; + const XrVector3f* vertexBuffer; + uint32_t triangleCount; + const uint32_t* indexBuffer; +} XrTriangleMeshCreateInfoFB; + +typedef XrResult (XRAPI_PTR *PFN_xrCreateTriangleMeshFB)(XrSession session, const XrTriangleMeshCreateInfoFB* createInfo, XrTriangleMeshFB* outTriangleMesh); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyTriangleMeshFB)(XrTriangleMeshFB mesh); +typedef XrResult (XRAPI_PTR *PFN_xrTriangleMeshGetVertexBufferFB)(XrTriangleMeshFB mesh, XrVector3f** outVertexBuffer); +typedef XrResult (XRAPI_PTR *PFN_xrTriangleMeshGetIndexBufferFB)(XrTriangleMeshFB mesh, uint32_t** outIndexBuffer); +typedef XrResult (XRAPI_PTR *PFN_xrTriangleMeshBeginUpdateFB)(XrTriangleMeshFB mesh); +typedef XrResult (XRAPI_PTR *PFN_xrTriangleMeshEndUpdateFB)(XrTriangleMeshFB mesh, uint32_t vertexCount, uint32_t triangleCount); +typedef XrResult (XRAPI_PTR *PFN_xrTriangleMeshBeginVertexBufferUpdateFB)(XrTriangleMeshFB mesh, uint32_t* outVertexCount); +typedef XrResult (XRAPI_PTR *PFN_xrTriangleMeshEndVertexBufferUpdateFB)(XrTriangleMeshFB mesh); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreateTriangleMeshFB( + XrSession session, + const XrTriangleMeshCreateInfoFB* createInfo, + XrTriangleMeshFB* outTriangleMesh); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyTriangleMeshFB( + XrTriangleMeshFB mesh); + +XRAPI_ATTR XrResult XRAPI_CALL xrTriangleMeshGetVertexBufferFB( + XrTriangleMeshFB mesh, + XrVector3f** outVertexBuffer); + +XRAPI_ATTR XrResult XRAPI_CALL xrTriangleMeshGetIndexBufferFB( + XrTriangleMeshFB mesh, + uint32_t** outIndexBuffer); + +XRAPI_ATTR XrResult XRAPI_CALL xrTriangleMeshBeginUpdateFB( + XrTriangleMeshFB mesh); + +XRAPI_ATTR XrResult XRAPI_CALL xrTriangleMeshEndUpdateFB( + XrTriangleMeshFB mesh, + uint32_t vertexCount, + uint32_t triangleCount); + +XRAPI_ATTR XrResult XRAPI_CALL xrTriangleMeshBeginVertexBufferUpdateFB( + XrTriangleMeshFB mesh, + uint32_t* outVertexCount); + +XRAPI_ATTR XrResult XRAPI_CALL xrTriangleMeshEndVertexBufferUpdateFB( + XrTriangleMeshFB mesh); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +#define XR_FB_passthrough 1 +XR_DEFINE_HANDLE(XrPassthroughFB) +XR_DEFINE_HANDLE(XrPassthroughLayerFB) +XR_DEFINE_HANDLE(XrGeometryInstanceFB) +#define XR_FB_passthrough_SPEC_VERSION 1 +#define XR_FB_PASSTHROUGH_EXTENSION_NAME "XR_FB_passthrough" +#define XR_PASSTHROUGH_COLOR_MAP_MONO_SIZE_FB 256 + +typedef enum XrPassthroughLayerPurposeFB { + XR_PASSTHROUGH_LAYER_PURPOSE_RECONSTRUCTION_FB = 0, + XR_PASSTHROUGH_LAYER_PURPOSE_PROJECTED_FB = 1, + XR_PASSTHROUGH_LAYER_PURPOSE_TRACKED_KEYBOARD_HANDS_FB = 1000203001, + XR_PASSTHROUGH_LAYER_PURPOSE_MAX_ENUM_FB = 0x7FFFFFFF +} XrPassthroughLayerPurposeFB; +typedef XrFlags64 XrPassthroughFlagsFB; + +// Flag bits for XrPassthroughFlagsFB +static const XrPassthroughFlagsFB XR_PASSTHROUGH_IS_RUNNING_AT_CREATION_BIT_FB = 0x00000001; + +typedef XrFlags64 XrPassthroughStateChangedFlagsFB; + +// Flag bits for XrPassthroughStateChangedFlagsFB +static const XrPassthroughStateChangedFlagsFB XR_PASSTHROUGH_STATE_CHANGED_REINIT_REQUIRED_BIT_FB = 0x00000001; +static const XrPassthroughStateChangedFlagsFB XR_PASSTHROUGH_STATE_CHANGED_NON_RECOVERABLE_ERROR_BIT_FB = 0x00000002; +static const XrPassthroughStateChangedFlagsFB XR_PASSTHROUGH_STATE_CHANGED_RECOVERABLE_ERROR_BIT_FB = 0x00000004; +static const XrPassthroughStateChangedFlagsFB XR_PASSTHROUGH_STATE_CHANGED_RESTORED_ERROR_BIT_FB = 0x00000008; + +// XrSystemPassthroughPropertiesFB extends XrSystemProperties +typedef struct XrSystemPassthroughPropertiesFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrBool32 supportsPassthrough; +} XrSystemPassthroughPropertiesFB; + +typedef struct XrPassthroughCreateInfoFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrPassthroughFlagsFB flags; +} XrPassthroughCreateInfoFB; + +typedef struct XrPassthroughLayerCreateInfoFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrPassthroughFB passthrough; + XrPassthroughFlagsFB flags; + XrPassthroughLayerPurposeFB purpose; +} XrPassthroughLayerCreateInfoFB; + +// XrCompositionLayerPassthroughFB extends XrCompositionLayerBaseHeader +typedef struct XrCompositionLayerPassthroughFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrCompositionLayerFlags flags; + XrSpace space; + XrPassthroughLayerFB layerHandle; +} XrCompositionLayerPassthroughFB; + +typedef struct XrGeometryInstanceCreateInfoFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrPassthroughLayerFB layer; + XrTriangleMeshFB mesh; + XrSpace baseSpace; + XrPosef pose; + XrVector3f scale; +} XrGeometryInstanceCreateInfoFB; + +typedef struct XrGeometryInstanceTransformFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpace baseSpace; + XrTime time; + XrPosef pose; + XrVector3f scale; +} XrGeometryInstanceTransformFB; + +typedef struct XrPassthroughStyleFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + float textureOpacityFactor; + XrColor4f edgeColor; +} XrPassthroughStyleFB; + +typedef struct XrPassthroughColorMapMonoToRgbaFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrColor4f textureColorMap[XR_PASSTHROUGH_COLOR_MAP_MONO_SIZE_FB]; +} XrPassthroughColorMapMonoToRgbaFB; + +typedef struct XrPassthroughColorMapMonoToMonoFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint8_t textureColorMap[XR_PASSTHROUGH_COLOR_MAP_MONO_SIZE_FB]; +} XrPassthroughColorMapMonoToMonoFB; + +typedef struct XrEventDataPassthroughStateChangedFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrPassthroughStateChangedFlagsFB flags; +} XrEventDataPassthroughStateChangedFB; + +typedef XrResult (XRAPI_PTR *PFN_xrCreatePassthroughFB)(XrSession session, const XrPassthroughCreateInfoFB* createInfo, XrPassthroughFB* outPassthrough); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyPassthroughFB)(XrPassthroughFB passthrough); +typedef XrResult (XRAPI_PTR *PFN_xrPassthroughStartFB)(XrPassthroughFB passthrough); +typedef XrResult (XRAPI_PTR *PFN_xrPassthroughPauseFB)(XrPassthroughFB passthrough); +typedef XrResult (XRAPI_PTR *PFN_xrCreatePassthroughLayerFB)(XrSession session, const XrPassthroughLayerCreateInfoFB* createInfo, XrPassthroughLayerFB* outLayer); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyPassthroughLayerFB)(XrPassthroughLayerFB layer); +typedef XrResult (XRAPI_PTR *PFN_xrPassthroughLayerPauseFB)(XrPassthroughLayerFB layer); +typedef XrResult (XRAPI_PTR *PFN_xrPassthroughLayerResumeFB)(XrPassthroughLayerFB layer); +typedef XrResult (XRAPI_PTR *PFN_xrPassthroughLayerSetStyleFB)(XrPassthroughLayerFB layer, const XrPassthroughStyleFB* style); +typedef XrResult (XRAPI_PTR *PFN_xrCreateGeometryInstanceFB)(XrSession session, const XrGeometryInstanceCreateInfoFB* createInfo, XrGeometryInstanceFB* outGeometryInstance); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyGeometryInstanceFB)(XrGeometryInstanceFB instance); +typedef XrResult (XRAPI_PTR *PFN_xrGeometryInstanceSetTransformFB)(XrGeometryInstanceFB instance, const XrGeometryInstanceTransformFB* transformation); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreatePassthroughFB( + XrSession session, + const XrPassthroughCreateInfoFB* createInfo, + XrPassthroughFB* outPassthrough); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyPassthroughFB( + XrPassthroughFB passthrough); + +XRAPI_ATTR XrResult XRAPI_CALL xrPassthroughStartFB( + XrPassthroughFB passthrough); + +XRAPI_ATTR XrResult XRAPI_CALL xrPassthroughPauseFB( + XrPassthroughFB passthrough); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreatePassthroughLayerFB( + XrSession session, + const XrPassthroughLayerCreateInfoFB* createInfo, + XrPassthroughLayerFB* outLayer); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyPassthroughLayerFB( + XrPassthroughLayerFB layer); + +XRAPI_ATTR XrResult XRAPI_CALL xrPassthroughLayerPauseFB( + XrPassthroughLayerFB layer); + +XRAPI_ATTR XrResult XRAPI_CALL xrPassthroughLayerResumeFB( + XrPassthroughLayerFB layer); + +XRAPI_ATTR XrResult XRAPI_CALL xrPassthroughLayerSetStyleFB( + XrPassthroughLayerFB layer, + const XrPassthroughStyleFB* style); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateGeometryInstanceFB( + XrSession session, + const XrGeometryInstanceCreateInfoFB* createInfo, + XrGeometryInstanceFB* outGeometryInstance); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyGeometryInstanceFB( + XrGeometryInstanceFB instance); + +XRAPI_ATTR XrResult XRAPI_CALL xrGeometryInstanceSetTransformFB( + XrGeometryInstanceFB instance, + const XrGeometryInstanceTransformFB* transformation); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +#define XR_FB_render_model 1 + +#define XR_NULL_RENDER_MODEL_KEY_FB 0 + +XR_DEFINE_ATOM(XrRenderModelKeyFB) +#define XR_FB_render_model_SPEC_VERSION 1 +#define XR_FB_RENDER_MODEL_EXTENSION_NAME "XR_FB_render_model" +#define XR_MAX_RENDER_MODEL_NAME_SIZE_FB 64 +typedef XrFlags64 XrRenderModelFlagsFB; + +// Flag bits for XrRenderModelFlagsFB + +typedef struct XrRenderModelPathInfoFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrPath path; +} XrRenderModelPathInfoFB; + +typedef struct XrRenderModelPropertiesFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t vendorId; + char modelName[XR_MAX_RENDER_MODEL_NAME_SIZE_FB]; + XrRenderModelKeyFB modelKey; + uint32_t modelVersion; + XrRenderModelFlagsFB flags; +} XrRenderModelPropertiesFB; + +typedef struct XrRenderModelBufferFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t bufferCapacityInput; + uint32_t bufferCountOutput; + uint8_t* buffer; +} XrRenderModelBufferFB; + +typedef struct XrRenderModelLoadInfoFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrRenderModelKeyFB modelKey; +} XrRenderModelLoadInfoFB; + +// XrSystemRenderModelPropertiesFB extends XrSystemProperties +typedef struct XrSystemRenderModelPropertiesFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsRenderModelLoading; +} XrSystemRenderModelPropertiesFB; + +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateRenderModelPathsFB)(XrSession session, uint32_t pathCapacityInput, uint32_t* pathCountOutput, XrRenderModelPathInfoFB* paths); +typedef XrResult (XRAPI_PTR *PFN_xrGetRenderModelPropertiesFB)(XrSession session, XrPath path, XrRenderModelPropertiesFB* properties); +typedef XrResult (XRAPI_PTR *PFN_xrLoadRenderModelFB)(XrSession session, const XrRenderModelLoadInfoFB* info, XrRenderModelBufferFB* buffer); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateRenderModelPathsFB( + XrSession session, + uint32_t pathCapacityInput, + uint32_t* pathCountOutput, + XrRenderModelPathInfoFB* paths); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetRenderModelPropertiesFB( + XrSession session, + XrPath path, + XrRenderModelPropertiesFB* properties); + +XRAPI_ATTR XrResult XRAPI_CALL xrLoadRenderModelFB( + XrSession session, + const XrRenderModelLoadInfoFB* info, + XrRenderModelBufferFB* buffer); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +#define XR_VARJO_foveated_rendering 1 +#define XR_VARJO_foveated_rendering_SPEC_VERSION 2 +#define XR_VARJO_FOVEATED_RENDERING_EXTENSION_NAME "XR_VARJO_foveated_rendering" +// XrViewLocateFoveatedRenderingVARJO extends XrViewLocateInfo +typedef struct XrViewLocateFoveatedRenderingVARJO { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrBool32 foveatedRenderingActive; +} XrViewLocateFoveatedRenderingVARJO; + +// XrFoveatedViewConfigurationViewVARJO extends XrViewConfigurationView +typedef struct XrFoveatedViewConfigurationViewVARJO { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 foveatedRenderingActive; +} XrFoveatedViewConfigurationViewVARJO; + +// XrSystemFoveatedRenderingPropertiesVARJO extends XrSystemProperties +typedef struct XrSystemFoveatedRenderingPropertiesVARJO { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsFoveatedRendering; +} XrSystemFoveatedRenderingPropertiesVARJO; + + + +#define XR_VARJO_composition_layer_depth_test 1 +#define XR_VARJO_composition_layer_depth_test_SPEC_VERSION 2 +#define XR_VARJO_COMPOSITION_LAYER_DEPTH_TEST_EXTENSION_NAME "XR_VARJO_composition_layer_depth_test" +// XrCompositionLayerDepthTestVARJO extends XrCompositionLayerProjection +typedef struct XrCompositionLayerDepthTestVARJO { + XrStructureType type; + const void* XR_MAY_ALIAS next; + float depthTestRangeNearZ; + float depthTestRangeFarZ; +} XrCompositionLayerDepthTestVARJO; + + + +#define XR_VARJO_environment_depth_estimation 1 +#define XR_VARJO_environment_depth_estimation_SPEC_VERSION 1 +#define XR_VARJO_ENVIRONMENT_DEPTH_ESTIMATION_EXTENSION_NAME "XR_VARJO_environment_depth_estimation" +typedef XrResult (XRAPI_PTR *PFN_xrSetEnvironmentDepthEstimationVARJO)(XrSession session, XrBool32 enabled); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrSetEnvironmentDepthEstimationVARJO( + XrSession session, + XrBool32 enabled); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +#define XR_VARJO_marker_tracking 1 +#define XR_VARJO_marker_tracking_SPEC_VERSION 1 +#define XR_VARJO_MARKER_TRACKING_EXTENSION_NAME "XR_VARJO_marker_tracking" +// XrSystemMarkerTrackingPropertiesVARJO extends XrSystemProperties +typedef struct XrSystemMarkerTrackingPropertiesVARJO { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsMarkerTracking; +} XrSystemMarkerTrackingPropertiesVARJO; + +typedef struct XrEventDataMarkerTrackingUpdateVARJO { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint64_t markerId; + XrBool32 isActive; + XrBool32 isPredicted; + XrTime time; +} XrEventDataMarkerTrackingUpdateVARJO; + +typedef struct XrMarkerSpaceCreateInfoVARJO { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint64_t markerId; + XrPosef poseInMarkerSpace; +} XrMarkerSpaceCreateInfoVARJO; + +typedef XrResult (XRAPI_PTR *PFN_xrSetMarkerTrackingVARJO)(XrSession session, XrBool32 enabled); +typedef XrResult (XRAPI_PTR *PFN_xrSetMarkerTrackingTimeoutVARJO)(XrSession session, uint64_t markerId, XrDuration timeout); +typedef XrResult (XRAPI_PTR *PFN_xrSetMarkerTrackingPredictionVARJO)(XrSession session, uint64_t markerId, XrBool32 enabled); +typedef XrResult (XRAPI_PTR *PFN_xrGetMarkerSizeVARJO)(XrSession session, uint64_t markerId, XrExtent2Df* size); +typedef XrResult (XRAPI_PTR *PFN_xrCreateMarkerSpaceVARJO)(XrSession session, const XrMarkerSpaceCreateInfoVARJO* createInfo, XrSpace* space); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrSetMarkerTrackingVARJO( + XrSession session, + XrBool32 enabled); + +XRAPI_ATTR XrResult XRAPI_CALL xrSetMarkerTrackingTimeoutVARJO( + XrSession session, + uint64_t markerId, + XrDuration timeout); + +XRAPI_ATTR XrResult XRAPI_CALL xrSetMarkerTrackingPredictionVARJO( + XrSession session, + uint64_t markerId, + XrBool32 enabled); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetMarkerSizeVARJO( + XrSession session, + uint64_t markerId, + XrExtent2Df* size); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateMarkerSpaceVARJO( + XrSession session, + const XrMarkerSpaceCreateInfoVARJO* createInfo, + XrSpace* space); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +#define XR_MSFT_spatial_anchor_persistence 1 +XR_DEFINE_HANDLE(XrSpatialAnchorStoreConnectionMSFT) +#define XR_MAX_SPATIAL_ANCHOR_NAME_SIZE_MSFT 256 +#define XR_MSFT_spatial_anchor_persistence_SPEC_VERSION 2 +#define XR_MSFT_SPATIAL_ANCHOR_PERSISTENCE_EXTENSION_NAME "XR_MSFT_spatial_anchor_persistence" +typedef struct XrSpatialAnchorPersistenceNameMSFT { + char name[XR_MAX_SPATIAL_ANCHOR_NAME_SIZE_MSFT]; +} XrSpatialAnchorPersistenceNameMSFT; + +typedef struct XrSpatialAnchorPersistenceInfoMSFT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpatialAnchorPersistenceNameMSFT spatialAnchorPersistenceName; + XrSpatialAnchorMSFT spatialAnchor; +} XrSpatialAnchorPersistenceInfoMSFT; + +typedef struct XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore; + XrSpatialAnchorPersistenceNameMSFT spatialAnchorPersistenceName; +} XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT; + +typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorStoreConnectionMSFT)(XrSession session, XrSpatialAnchorStoreConnectionMSFT* spatialAnchorStore); +typedef XrResult (XRAPI_PTR *PFN_xrDestroySpatialAnchorStoreConnectionMSFT)(XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore); +typedef XrResult (XRAPI_PTR *PFN_xrPersistSpatialAnchorMSFT)(XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore, const XrSpatialAnchorPersistenceInfoMSFT* spatialAnchorPersistenceInfo); +typedef XrResult (XRAPI_PTR *PFN_xrEnumeratePersistedSpatialAnchorNamesMSFT)(XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore, uint32_t spatialAnchorNamesCapacityInput, uint32_t* spatialAnchorNamesCountOutput, XrSpatialAnchorPersistenceNameMSFT* persistedAnchorNames); +typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorFromPersistedNameMSFT)(XrSession session, const XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT* spatialAnchorCreateInfo, XrSpatialAnchorMSFT* spatialAnchor); +typedef XrResult (XRAPI_PTR *PFN_xrUnpersistSpatialAnchorMSFT)(XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore, const XrSpatialAnchorPersistenceNameMSFT* spatialAnchorPersistenceName); +typedef XrResult (XRAPI_PTR *PFN_xrClearSpatialAnchorStoreMSFT)(XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialAnchorStoreConnectionMSFT( + XrSession session, + XrSpatialAnchorStoreConnectionMSFT* spatialAnchorStore); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroySpatialAnchorStoreConnectionMSFT( + XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore); + +XRAPI_ATTR XrResult XRAPI_CALL xrPersistSpatialAnchorMSFT( + XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore, + const XrSpatialAnchorPersistenceInfoMSFT* spatialAnchorPersistenceInfo); + +XRAPI_ATTR XrResult XRAPI_CALL xrEnumeratePersistedSpatialAnchorNamesMSFT( + XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore, + uint32_t spatialAnchorNamesCapacityInput, + uint32_t* spatialAnchorNamesCountOutput, + XrSpatialAnchorPersistenceNameMSFT* persistedAnchorNames); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialAnchorFromPersistedNameMSFT( + XrSession session, + const XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT* spatialAnchorCreateInfo, + XrSpatialAnchorMSFT* spatialAnchor); + +XRAPI_ATTR XrResult XRAPI_CALL xrUnpersistSpatialAnchorMSFT( + XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore, + const XrSpatialAnchorPersistenceNameMSFT* spatialAnchorPersistenceName); + +XRAPI_ATTR XrResult XRAPI_CALL xrClearSpatialAnchorStoreMSFT( + XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +#define XR_FB_space_warp 1 +#define XR_FB_space_warp_SPEC_VERSION 1 +#define XR_FB_SPACE_WARP_EXTENSION_NAME "XR_FB_space_warp" +typedef XrFlags64 XrCompositionLayerSpaceWarpInfoFlagsFB; + +// Flag bits for XrCompositionLayerSpaceWarpInfoFlagsFB + +// XrCompositionLayerSpaceWarpInfoFB extends XrCompositionLayerProjectionView +typedef struct XrCompositionLayerSpaceWarpInfoFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrCompositionLayerSpaceWarpInfoFlagsFB layerFlags; + XrSwapchainSubImage motionVectorSubImage; + XrPosef appSpaceDeltaPose; + XrSwapchainSubImage depthSubImage; + float minDepth; + float maxDepth; + float nearZ; + float farZ; +} XrCompositionLayerSpaceWarpInfoFB; + +// XrSystemSpaceWarpPropertiesFB extends XrSystemProperties +typedef struct XrSystemSpaceWarpPropertiesFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t recommendedMotionVectorImageRectWidth; + uint32_t recommendedMotionVectorImageRectHeight; +} XrSystemSpaceWarpPropertiesFB; + + + +#define XR_ALMALENCE_digital_lens_control 1 +#define XR_ALMALENCE_digital_lens_control_SPEC_VERSION 1 +#define XR_ALMALENCE_DIGITAL_LENS_CONTROL_EXTENSION_NAME "XR_ALMALENCE_digital_lens_control" +typedef XrFlags64 XrDigitalLensControlFlagsALMALENCE; + +// Flag bits for XrDigitalLensControlFlagsALMALENCE +static const XrDigitalLensControlFlagsALMALENCE XR_DIGITAL_LENS_CONTROL_PROCESSING_DISABLE_BIT_ALMALENCE = 0x00000001; + +typedef struct XrDigitalLensControlALMALENCE { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrDigitalLensControlFlagsALMALENCE flags; +} XrDigitalLensControlALMALENCE; + +typedef XrResult (XRAPI_PTR *PFN_xrSetDigitalLensControlALMALENCE)(XrSession session, const XrDigitalLensControlALMALENCE* digitalLensControl); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrSetDigitalLensControlALMALENCE( + XrSession session, + const XrDigitalLensControlALMALENCE* digitalLensControl); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +#define XR_FB_passthrough_keyboard_hands 1 +#define XR_FB_passthrough_keyboard_hands_SPEC_VERSION 1 +#define XR_FB_PASSTHROUGH_KEYBOARD_HANDS_EXTENSION_NAME "XR_FB_passthrough_keyboard_hands" +typedef struct XrPassthroughKeyboardHandsIntensityFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + float leftHandIntensity; + float rightHandIntensity; +} XrPassthroughKeyboardHandsIntensityFB; + +typedef XrResult (XRAPI_PTR *PFN_xrPassthroughLayerSetKeyboardHandsIntensityFB)(XrPassthroughLayerFB layer, const XrPassthroughKeyboardHandsIntensityFB* intensity); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrPassthroughLayerSetKeyboardHandsIntensityFB( + XrPassthroughLayerFB layer, + const XrPassthroughKeyboardHandsIntensityFB* intensity); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +#define XR_EXT_uuid 1 +#define XR_EXT_uuid_SPEC_VERSION 1 +#define XR_EXT_UUID_EXTENSION_NAME "XR_EXT_uuid" +#define XR_UUID_SIZE_EXT 16 +typedef struct XrUuidEXT { + uint8_t data[XR_UUID_SIZE_EXT]; +} XrUuidEXT; + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/ext/openxr/openxr_platform.h b/ext/openxr/openxr_platform.h new file mode 100755 index 000000000000..eb5e5f8c4be9 --- /dev/null +++ b/ext/openxr/openxr_platform.h @@ -0,0 +1,675 @@ +#ifndef OPENXR_PLATFORM_H_ +#define OPENXR_PLATFORM_H_ 1 + +/* +** Copyright (c) 2017-2022, 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 + +#define XR_KHR_android_thread_settings 1 +#define XR_KHR_android_thread_settings_SPEC_VERSION 5 +#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 + +#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 + +#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 + +#define XR_KHR_vulkan_swapchain_format_list 1 +#define XR_KHR_vulkan_swapchain_format_list_SPEC_VERSION 4 +#define XR_KHR_VULKAN_SWAPCHAIN_FORMAT_LIST_EXTENSION_NAME "XR_KHR_vulkan_swapchain_format_list" +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 + +#define XR_KHR_opengl_enable 1 +#define XR_KHR_opengl_enable_SPEC_VERSION 10 +#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 + +#define XR_KHR_opengl_es_enable 1 +#define XR_KHR_opengl_es_enable_SPEC_VERSION 8 +#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 + +#define XR_KHR_vulkan_enable 1 +#define XR_KHR_vulkan_enable_SPEC_VERSION 8 +#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 + +#define XR_KHR_D3D11_enable 1 +#define XR_KHR_D3D11_enable_SPEC_VERSION 8 +#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 + +#define XR_KHR_D3D12_enable 1 +#define XR_KHR_D3D12_enable_SPEC_VERSION 8 +#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_PLATFORM_WIN32 + +#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 + +#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 + +#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 + +#define XR_KHR_vulkan_enable2 1 +#define XR_KHR_vulkan_enable2_SPEC_VERSION 2 +#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 + +#define XR_MNDX_egl_enable 1 +#define XR_MNDX_egl_enable_SPEC_VERSION 1 +#define XR_MNDX_EGL_ENABLE_EXTENSION_NAME "XR_MNDX_egl_enable" +// XrGraphicsBindingEGLMNDX extends XrSessionCreateInfo +typedef struct XrGraphicsBindingEGLMNDX { + XrStructureType type; + const void* XR_MAY_ALIAS next; + PFNEGLGETPROCADDRESSPROC getProcAddress; + EGLDisplay display; + EGLConfig config; + EGLContext context; +} XrGraphicsBindingEGLMNDX; + +#endif /* XR_USE_PLATFORM_EGL */ + +#ifdef XR_USE_PLATFORM_WIN32 + +#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 + +#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 + +#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_WIN32 + +#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 + +#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 + +#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 + +#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 + +#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 __cplusplus +} +#endif + +#endif diff --git a/ext/openxr/openxr_platform_defines.h b/ext/openxr/openxr_platform_defines.h new file mode 100755 index 000000000000..31fa05a0c848 --- /dev/null +++ b/ext/openxr/openxr_platform_defines.h @@ -0,0 +1,110 @@ +/* +** Copyright (c) 2017-2022, 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 + +#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 +#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 + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/ext/openxr/openxr_reflection.h b/ext/openxr/openxr_reflection.h new file mode 100755 index 000000000000..8d8e36377dbd --- /dev/null +++ b/ext/openxr/openxr_reflection.h @@ -0,0 +1,2744 @@ +#ifndef OPENXR_REFLECTION_H_ +#define OPENXR_REFLECTION_H_ 1 + +/* +** Copyright (c) 2017-2022, 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" + +/* +This file contains expansion macros (X Macros) for OpenXR enumerations and structures. +Example of how to use expansion macros to make an enum-to-string function: + +#define XR_ENUM_CASE_STR(name, val) case name: return #name; +#define XR_ENUM_STR(enumType) \ + constexpr const char* XrEnumStr(enumType e) { \ + switch (e) { \ + XR_LIST_ENUM_##enumType(XR_ENUM_CASE_STR) \ + default: return "Unknown"; \ + } \ + } \ + +XR_ENUM_STR(XrResult); +*/ + +#define XR_LIST_ENUM_XrResult(_) \ + _(XR_SUCCESS, 0) \ + _(XR_TIMEOUT_EXPIRED, 1) \ + _(XR_SESSION_LOSS_PENDING, 3) \ + _(XR_EVENT_UNAVAILABLE, 4) \ + _(XR_SPACE_BOUNDS_UNAVAILABLE, 7) \ + _(XR_SESSION_NOT_FOCUSED, 8) \ + _(XR_FRAME_DISCARDED, 9) \ + _(XR_ERROR_VALIDATION_FAILURE, -1) \ + _(XR_ERROR_RUNTIME_FAILURE, -2) \ + _(XR_ERROR_OUT_OF_MEMORY, -3) \ + _(XR_ERROR_API_VERSION_UNSUPPORTED, -4) \ + _(XR_ERROR_INITIALIZATION_FAILED, -6) \ + _(XR_ERROR_FUNCTION_UNSUPPORTED, -7) \ + _(XR_ERROR_FEATURE_UNSUPPORTED, -8) \ + _(XR_ERROR_EXTENSION_NOT_PRESENT, -9) \ + _(XR_ERROR_LIMIT_REACHED, -10) \ + _(XR_ERROR_SIZE_INSUFFICIENT, -11) \ + _(XR_ERROR_HANDLE_INVALID, -12) \ + _(XR_ERROR_INSTANCE_LOST, -13) \ + _(XR_ERROR_SESSION_RUNNING, -14) \ + _(XR_ERROR_SESSION_NOT_RUNNING, -16) \ + _(XR_ERROR_SESSION_LOST, -17) \ + _(XR_ERROR_SYSTEM_INVALID, -18) \ + _(XR_ERROR_PATH_INVALID, -19) \ + _(XR_ERROR_PATH_COUNT_EXCEEDED, -20) \ + _(XR_ERROR_PATH_FORMAT_INVALID, -21) \ + _(XR_ERROR_PATH_UNSUPPORTED, -22) \ + _(XR_ERROR_LAYER_INVALID, -23) \ + _(XR_ERROR_LAYER_LIMIT_EXCEEDED, -24) \ + _(XR_ERROR_SWAPCHAIN_RECT_INVALID, -25) \ + _(XR_ERROR_SWAPCHAIN_FORMAT_UNSUPPORTED, -26) \ + _(XR_ERROR_ACTION_TYPE_MISMATCH, -27) \ + _(XR_ERROR_SESSION_NOT_READY, -28) \ + _(XR_ERROR_SESSION_NOT_STOPPING, -29) \ + _(XR_ERROR_TIME_INVALID, -30) \ + _(XR_ERROR_REFERENCE_SPACE_UNSUPPORTED, -31) \ + _(XR_ERROR_FILE_ACCESS_ERROR, -32) \ + _(XR_ERROR_FILE_CONTENTS_INVALID, -33) \ + _(XR_ERROR_FORM_FACTOR_UNSUPPORTED, -34) \ + _(XR_ERROR_FORM_FACTOR_UNAVAILABLE, -35) \ + _(XR_ERROR_API_LAYER_NOT_PRESENT, -36) \ + _(XR_ERROR_CALL_ORDER_INVALID, -37) \ + _(XR_ERROR_GRAPHICS_DEVICE_INVALID, -38) \ + _(XR_ERROR_POSE_INVALID, -39) \ + _(XR_ERROR_INDEX_OUT_OF_RANGE, -40) \ + _(XR_ERROR_VIEW_CONFIGURATION_TYPE_UNSUPPORTED, -41) \ + _(XR_ERROR_ENVIRONMENT_BLEND_MODE_UNSUPPORTED, -42) \ + _(XR_ERROR_NAME_DUPLICATED, -44) \ + _(XR_ERROR_NAME_INVALID, -45) \ + _(XR_ERROR_ACTIONSET_NOT_ATTACHED, -46) \ + _(XR_ERROR_ACTIONSETS_ALREADY_ATTACHED, -47) \ + _(XR_ERROR_LOCALIZED_NAME_DUPLICATED, -48) \ + _(XR_ERROR_LOCALIZED_NAME_INVALID, -49) \ + _(XR_ERROR_GRAPHICS_REQUIREMENTS_CALL_MISSING, -50) \ + _(XR_ERROR_RUNTIME_UNAVAILABLE, -51) \ + _(XR_ERROR_ANDROID_THREAD_SETTINGS_ID_INVALID_KHR, -1000003000) \ + _(XR_ERROR_ANDROID_THREAD_SETTINGS_FAILURE_KHR, -1000003001) \ + _(XR_ERROR_CREATE_SPATIAL_ANCHOR_FAILED_MSFT, -1000039001) \ + _(XR_ERROR_SECONDARY_VIEW_CONFIGURATION_TYPE_NOT_ENABLED_MSFT, -1000053000) \ + _(XR_ERROR_CONTROLLER_MODEL_KEY_INVALID_MSFT, -1000055000) \ + _(XR_ERROR_REPROJECTION_MODE_UNSUPPORTED_MSFT, -1000066000) \ + _(XR_ERROR_COMPUTE_NEW_SCENE_NOT_COMPLETED_MSFT, -1000097000) \ + _(XR_ERROR_SCENE_COMPONENT_ID_INVALID_MSFT, -1000097001) \ + _(XR_ERROR_SCENE_COMPONENT_TYPE_MISMATCH_MSFT, -1000097002) \ + _(XR_ERROR_SCENE_MESH_BUFFER_ID_INVALID_MSFT, -1000097003) \ + _(XR_ERROR_SCENE_COMPUTE_FEATURE_INCOMPATIBLE_MSFT, -1000097004) \ + _(XR_ERROR_SCENE_COMPUTE_CONSISTENCY_MISMATCH_MSFT, -1000097005) \ + _(XR_ERROR_DISPLAY_REFRESH_RATE_UNSUPPORTED_FB, -1000101000) \ + _(XR_ERROR_COLOR_SPACE_UNSUPPORTED_FB, -1000108000) \ + _(XR_ERROR_UNEXPECTED_STATE_PASSTHROUGH_FB, -1000118000) \ + _(XR_ERROR_FEATURE_ALREADY_CREATED_PASSTHROUGH_FB, -1000118001) \ + _(XR_ERROR_FEATURE_REQUIRED_PASSTHROUGH_FB, -1000118002) \ + _(XR_ERROR_NOT_PERMITTED_PASSTHROUGH_FB, -1000118003) \ + _(XR_ERROR_INSUFFICIENT_RESOURCES_PASSTHROUGH_FB, -1000118004) \ + _(XR_ERROR_UNKNOWN_PASSTHROUGH_FB, -1000118050) \ + _(XR_ERROR_RENDER_MODEL_KEY_INVALID_FB, -1000119000) \ + _(XR_RENDER_MODEL_UNAVAILABLE_FB, 1000119020) \ + _(XR_ERROR_MARKER_NOT_TRACKED_VARJO, -1000124000) \ + _(XR_ERROR_MARKER_ID_INVALID_VARJO, -1000124001) \ + _(XR_ERROR_SPATIAL_ANCHOR_NAME_NOT_FOUND_MSFT, -1000142001) \ + _(XR_ERROR_SPATIAL_ANCHOR_NAME_INVALID_MSFT, -1000142002) \ + _(XR_RESULT_MAX_ENUM, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrStructureType(_) \ + _(XR_TYPE_UNKNOWN, 0) \ + _(XR_TYPE_API_LAYER_PROPERTIES, 1) \ + _(XR_TYPE_EXTENSION_PROPERTIES, 2) \ + _(XR_TYPE_INSTANCE_CREATE_INFO, 3) \ + _(XR_TYPE_SYSTEM_GET_INFO, 4) \ + _(XR_TYPE_SYSTEM_PROPERTIES, 5) \ + _(XR_TYPE_VIEW_LOCATE_INFO, 6) \ + _(XR_TYPE_VIEW, 7) \ + _(XR_TYPE_SESSION_CREATE_INFO, 8) \ + _(XR_TYPE_SWAPCHAIN_CREATE_INFO, 9) \ + _(XR_TYPE_SESSION_BEGIN_INFO, 10) \ + _(XR_TYPE_VIEW_STATE, 11) \ + _(XR_TYPE_FRAME_END_INFO, 12) \ + _(XR_TYPE_HAPTIC_VIBRATION, 13) \ + _(XR_TYPE_EVENT_DATA_BUFFER, 16) \ + _(XR_TYPE_EVENT_DATA_INSTANCE_LOSS_PENDING, 17) \ + _(XR_TYPE_EVENT_DATA_SESSION_STATE_CHANGED, 18) \ + _(XR_TYPE_ACTION_STATE_BOOLEAN, 23) \ + _(XR_TYPE_ACTION_STATE_FLOAT, 24) \ + _(XR_TYPE_ACTION_STATE_VECTOR2F, 25) \ + _(XR_TYPE_ACTION_STATE_POSE, 27) \ + _(XR_TYPE_ACTION_SET_CREATE_INFO, 28) \ + _(XR_TYPE_ACTION_CREATE_INFO, 29) \ + _(XR_TYPE_INSTANCE_PROPERTIES, 32) \ + _(XR_TYPE_FRAME_WAIT_INFO, 33) \ + _(XR_TYPE_COMPOSITION_LAYER_PROJECTION, 35) \ + _(XR_TYPE_COMPOSITION_LAYER_QUAD, 36) \ + _(XR_TYPE_REFERENCE_SPACE_CREATE_INFO, 37) \ + _(XR_TYPE_ACTION_SPACE_CREATE_INFO, 38) \ + _(XR_TYPE_EVENT_DATA_REFERENCE_SPACE_CHANGE_PENDING, 40) \ + _(XR_TYPE_VIEW_CONFIGURATION_VIEW, 41) \ + _(XR_TYPE_SPACE_LOCATION, 42) \ + _(XR_TYPE_SPACE_VELOCITY, 43) \ + _(XR_TYPE_FRAME_STATE, 44) \ + _(XR_TYPE_VIEW_CONFIGURATION_PROPERTIES, 45) \ + _(XR_TYPE_FRAME_BEGIN_INFO, 46) \ + _(XR_TYPE_COMPOSITION_LAYER_PROJECTION_VIEW, 48) \ + _(XR_TYPE_EVENT_DATA_EVENTS_LOST, 49) \ + _(XR_TYPE_INTERACTION_PROFILE_SUGGESTED_BINDING, 51) \ + _(XR_TYPE_EVENT_DATA_INTERACTION_PROFILE_CHANGED, 52) \ + _(XR_TYPE_INTERACTION_PROFILE_STATE, 53) \ + _(XR_TYPE_SWAPCHAIN_IMAGE_ACQUIRE_INFO, 55) \ + _(XR_TYPE_SWAPCHAIN_IMAGE_WAIT_INFO, 56) \ + _(XR_TYPE_SWAPCHAIN_IMAGE_RELEASE_INFO, 57) \ + _(XR_TYPE_ACTION_STATE_GET_INFO, 58) \ + _(XR_TYPE_HAPTIC_ACTION_INFO, 59) \ + _(XR_TYPE_SESSION_ACTION_SETS_ATTACH_INFO, 60) \ + _(XR_TYPE_ACTIONS_SYNC_INFO, 61) \ + _(XR_TYPE_BOUND_SOURCES_FOR_ACTION_ENUMERATE_INFO, 62) \ + _(XR_TYPE_INPUT_SOURCE_LOCALIZED_NAME_GET_INFO, 63) \ + _(XR_TYPE_COMPOSITION_LAYER_CUBE_KHR, 1000006000) \ + _(XR_TYPE_INSTANCE_CREATE_INFO_ANDROID_KHR, 1000008000) \ + _(XR_TYPE_COMPOSITION_LAYER_DEPTH_INFO_KHR, 1000010000) \ + _(XR_TYPE_VULKAN_SWAPCHAIN_FORMAT_LIST_CREATE_INFO_KHR, 1000014000) \ + _(XR_TYPE_EVENT_DATA_PERF_SETTINGS_EXT, 1000015000) \ + _(XR_TYPE_COMPOSITION_LAYER_CYLINDER_KHR, 1000017000) \ + _(XR_TYPE_COMPOSITION_LAYER_EQUIRECT_KHR, 1000018000) \ + _(XR_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT, 1000019000) \ + _(XR_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT, 1000019001) \ + _(XR_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT, 1000019002) \ + _(XR_TYPE_DEBUG_UTILS_LABEL_EXT, 1000019003) \ + _(XR_TYPE_GRAPHICS_BINDING_OPENGL_WIN32_KHR, 1000023000) \ + _(XR_TYPE_GRAPHICS_BINDING_OPENGL_XLIB_KHR, 1000023001) \ + _(XR_TYPE_GRAPHICS_BINDING_OPENGL_XCB_KHR, 1000023002) \ + _(XR_TYPE_GRAPHICS_BINDING_OPENGL_WAYLAND_KHR, 1000023003) \ + _(XR_TYPE_SWAPCHAIN_IMAGE_OPENGL_KHR, 1000023004) \ + _(XR_TYPE_GRAPHICS_REQUIREMENTS_OPENGL_KHR, 1000023005) \ + _(XR_TYPE_GRAPHICS_BINDING_OPENGL_ES_ANDROID_KHR, 1000024001) \ + _(XR_TYPE_SWAPCHAIN_IMAGE_OPENGL_ES_KHR, 1000024002) \ + _(XR_TYPE_GRAPHICS_REQUIREMENTS_OPENGL_ES_KHR, 1000024003) \ + _(XR_TYPE_GRAPHICS_BINDING_VULKAN_KHR, 1000025000) \ + _(XR_TYPE_SWAPCHAIN_IMAGE_VULKAN_KHR, 1000025001) \ + _(XR_TYPE_GRAPHICS_REQUIREMENTS_VULKAN_KHR, 1000025002) \ + _(XR_TYPE_GRAPHICS_BINDING_D3D11_KHR, 1000027000) \ + _(XR_TYPE_SWAPCHAIN_IMAGE_D3D11_KHR, 1000027001) \ + _(XR_TYPE_GRAPHICS_REQUIREMENTS_D3D11_KHR, 1000027002) \ + _(XR_TYPE_GRAPHICS_BINDING_D3D12_KHR, 1000028000) \ + _(XR_TYPE_SWAPCHAIN_IMAGE_D3D12_KHR, 1000028001) \ + _(XR_TYPE_GRAPHICS_REQUIREMENTS_D3D12_KHR, 1000028002) \ + _(XR_TYPE_SYSTEM_EYE_GAZE_INTERACTION_PROPERTIES_EXT, 1000030000) \ + _(XR_TYPE_EYE_GAZE_SAMPLE_TIME_EXT, 1000030001) \ + _(XR_TYPE_VISIBILITY_MASK_KHR, 1000031000) \ + _(XR_TYPE_EVENT_DATA_VISIBILITY_MASK_CHANGED_KHR, 1000031001) \ + _(XR_TYPE_SESSION_CREATE_INFO_OVERLAY_EXTX, 1000033000) \ + _(XR_TYPE_EVENT_DATA_MAIN_SESSION_VISIBILITY_CHANGED_EXTX, 1000033003) \ + _(XR_TYPE_COMPOSITION_LAYER_COLOR_SCALE_BIAS_KHR, 1000034000) \ + _(XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_MSFT, 1000039000) \ + _(XR_TYPE_SPATIAL_ANCHOR_SPACE_CREATE_INFO_MSFT, 1000039001) \ + _(XR_TYPE_COMPOSITION_LAYER_IMAGE_LAYOUT_FB, 1000040000) \ + _(XR_TYPE_COMPOSITION_LAYER_ALPHA_BLEND_FB, 1000041001) \ + _(XR_TYPE_VIEW_CONFIGURATION_DEPTH_RANGE_EXT, 1000046000) \ + _(XR_TYPE_GRAPHICS_BINDING_EGL_MNDX, 1000048004) \ + _(XR_TYPE_SPATIAL_GRAPH_NODE_SPACE_CREATE_INFO_MSFT, 1000049000) \ + _(XR_TYPE_SYSTEM_HAND_TRACKING_PROPERTIES_EXT, 1000051000) \ + _(XR_TYPE_HAND_TRACKER_CREATE_INFO_EXT, 1000051001) \ + _(XR_TYPE_HAND_JOINTS_LOCATE_INFO_EXT, 1000051002) \ + _(XR_TYPE_HAND_JOINT_LOCATIONS_EXT, 1000051003) \ + _(XR_TYPE_HAND_JOINT_VELOCITIES_EXT, 1000051004) \ + _(XR_TYPE_SYSTEM_HAND_TRACKING_MESH_PROPERTIES_MSFT, 1000052000) \ + _(XR_TYPE_HAND_MESH_SPACE_CREATE_INFO_MSFT, 1000052001) \ + _(XR_TYPE_HAND_MESH_UPDATE_INFO_MSFT, 1000052002) \ + _(XR_TYPE_HAND_MESH_MSFT, 1000052003) \ + _(XR_TYPE_HAND_POSE_TYPE_INFO_MSFT, 1000052004) \ + _(XR_TYPE_SECONDARY_VIEW_CONFIGURATION_SESSION_BEGIN_INFO_MSFT, 1000053000) \ + _(XR_TYPE_SECONDARY_VIEW_CONFIGURATION_STATE_MSFT, 1000053001) \ + _(XR_TYPE_SECONDARY_VIEW_CONFIGURATION_FRAME_STATE_MSFT, 1000053002) \ + _(XR_TYPE_SECONDARY_VIEW_CONFIGURATION_FRAME_END_INFO_MSFT, 1000053003) \ + _(XR_TYPE_SECONDARY_VIEW_CONFIGURATION_LAYER_INFO_MSFT, 1000053004) \ + _(XR_TYPE_SECONDARY_VIEW_CONFIGURATION_SWAPCHAIN_CREATE_INFO_MSFT, 1000053005) \ + _(XR_TYPE_CONTROLLER_MODEL_KEY_STATE_MSFT, 1000055000) \ + _(XR_TYPE_CONTROLLER_MODEL_NODE_PROPERTIES_MSFT, 1000055001) \ + _(XR_TYPE_CONTROLLER_MODEL_PROPERTIES_MSFT, 1000055002) \ + _(XR_TYPE_CONTROLLER_MODEL_NODE_STATE_MSFT, 1000055003) \ + _(XR_TYPE_CONTROLLER_MODEL_STATE_MSFT, 1000055004) \ + _(XR_TYPE_VIEW_CONFIGURATION_VIEW_FOV_EPIC, 1000059000) \ + _(XR_TYPE_HOLOGRAPHIC_WINDOW_ATTACHMENT_MSFT, 1000063000) \ + _(XR_TYPE_COMPOSITION_LAYER_REPROJECTION_INFO_MSFT, 1000066000) \ + _(XR_TYPE_COMPOSITION_LAYER_REPROJECTION_PLANE_OVERRIDE_MSFT, 1000066001) \ + _(XR_TYPE_ANDROID_SURFACE_SWAPCHAIN_CREATE_INFO_FB, 1000070000) \ + _(XR_TYPE_COMPOSITION_LAYER_SECURE_CONTENT_FB, 1000072000) \ + _(XR_TYPE_INTERACTION_PROFILE_ANALOG_THRESHOLD_VALVE, 1000079000) \ + _(XR_TYPE_HAND_JOINTS_MOTION_RANGE_INFO_EXT, 1000080000) \ + _(XR_TYPE_LOADER_INIT_INFO_ANDROID_KHR, 1000089000) \ + _(XR_TYPE_VULKAN_INSTANCE_CREATE_INFO_KHR, 1000090000) \ + _(XR_TYPE_VULKAN_DEVICE_CREATE_INFO_KHR, 1000090001) \ + _(XR_TYPE_VULKAN_GRAPHICS_DEVICE_GET_INFO_KHR, 1000090003) \ + _(XR_TYPE_COMPOSITION_LAYER_EQUIRECT2_KHR, 1000091000) \ + _(XR_TYPE_SCENE_OBSERVER_CREATE_INFO_MSFT, 1000097000) \ + _(XR_TYPE_SCENE_CREATE_INFO_MSFT, 1000097001) \ + _(XR_TYPE_NEW_SCENE_COMPUTE_INFO_MSFT, 1000097002) \ + _(XR_TYPE_VISUAL_MESH_COMPUTE_LOD_INFO_MSFT, 1000097003) \ + _(XR_TYPE_SCENE_COMPONENTS_MSFT, 1000097004) \ + _(XR_TYPE_SCENE_COMPONENTS_GET_INFO_MSFT, 1000097005) \ + _(XR_TYPE_SCENE_COMPONENT_LOCATIONS_MSFT, 1000097006) \ + _(XR_TYPE_SCENE_COMPONENTS_LOCATE_INFO_MSFT, 1000097007) \ + _(XR_TYPE_SCENE_OBJECTS_MSFT, 1000097008) \ + _(XR_TYPE_SCENE_COMPONENT_PARENT_FILTER_INFO_MSFT, 1000097009) \ + _(XR_TYPE_SCENE_OBJECT_TYPES_FILTER_INFO_MSFT, 1000097010) \ + _(XR_TYPE_SCENE_PLANES_MSFT, 1000097011) \ + _(XR_TYPE_SCENE_PLANE_ALIGNMENT_FILTER_INFO_MSFT, 1000097012) \ + _(XR_TYPE_SCENE_MESHES_MSFT, 1000097013) \ + _(XR_TYPE_SCENE_MESH_BUFFERS_GET_INFO_MSFT, 1000097014) \ + _(XR_TYPE_SCENE_MESH_BUFFERS_MSFT, 1000097015) \ + _(XR_TYPE_SCENE_MESH_VERTEX_BUFFER_MSFT, 1000097016) \ + _(XR_TYPE_SCENE_MESH_INDICES_UINT32_MSFT, 1000097017) \ + _(XR_TYPE_SCENE_MESH_INDICES_UINT16_MSFT, 1000097018) \ + _(XR_TYPE_SERIALIZED_SCENE_FRAGMENT_DATA_GET_INFO_MSFT, 1000098000) \ + _(XR_TYPE_SCENE_DESERIALIZE_INFO_MSFT, 1000098001) \ + _(XR_TYPE_EVENT_DATA_DISPLAY_REFRESH_RATE_CHANGED_FB, 1000101000) \ + _(XR_TYPE_VIVE_TRACKER_PATHS_HTCX, 1000103000) \ + _(XR_TYPE_EVENT_DATA_VIVE_TRACKER_CONNECTED_HTCX, 1000103001) \ + _(XR_TYPE_SYSTEM_FACIAL_TRACKING_PROPERTIES_HTC, 1000104000) \ + _(XR_TYPE_FACIAL_TRACKER_CREATE_INFO_HTC, 1000104001) \ + _(XR_TYPE_FACIAL_EXPRESSIONS_HTC, 1000104002) \ + _(XR_TYPE_SYSTEM_COLOR_SPACE_PROPERTIES_FB, 1000108000) \ + _(XR_TYPE_HAND_TRACKING_MESH_FB, 1000110001) \ + _(XR_TYPE_HAND_TRACKING_SCALE_FB, 1000110003) \ + _(XR_TYPE_HAND_TRACKING_AIM_STATE_FB, 1000111001) \ + _(XR_TYPE_HAND_TRACKING_CAPSULES_STATE_FB, 1000112000) \ + _(XR_TYPE_FOVEATION_PROFILE_CREATE_INFO_FB, 1000114000) \ + _(XR_TYPE_SWAPCHAIN_CREATE_INFO_FOVEATION_FB, 1000114001) \ + _(XR_TYPE_SWAPCHAIN_STATE_FOVEATION_FB, 1000114002) \ + _(XR_TYPE_FOVEATION_LEVEL_PROFILE_CREATE_INFO_FB, 1000115000) \ + _(XR_TYPE_KEYBOARD_SPACE_CREATE_INFO_FB, 1000116009) \ + _(XR_TYPE_KEYBOARD_TRACKING_QUERY_FB, 1000116004) \ + _(XR_TYPE_SYSTEM_KEYBOARD_TRACKING_PROPERTIES_FB, 1000116002) \ + _(XR_TYPE_TRIANGLE_MESH_CREATE_INFO_FB, 1000117001) \ + _(XR_TYPE_SYSTEM_PASSTHROUGH_PROPERTIES_FB, 1000118000) \ + _(XR_TYPE_PASSTHROUGH_CREATE_INFO_FB, 1000118001) \ + _(XR_TYPE_PASSTHROUGH_LAYER_CREATE_INFO_FB, 1000118002) \ + _(XR_TYPE_COMPOSITION_LAYER_PASSTHROUGH_FB, 1000118003) \ + _(XR_TYPE_GEOMETRY_INSTANCE_CREATE_INFO_FB, 1000118004) \ + _(XR_TYPE_GEOMETRY_INSTANCE_TRANSFORM_FB, 1000118005) \ + _(XR_TYPE_PASSTHROUGH_STYLE_FB, 1000118020) \ + _(XR_TYPE_PASSTHROUGH_COLOR_MAP_MONO_TO_RGBA_FB, 1000118021) \ + _(XR_TYPE_PASSTHROUGH_COLOR_MAP_MONO_TO_MONO_FB, 1000118022) \ + _(XR_TYPE_EVENT_DATA_PASSTHROUGH_STATE_CHANGED_FB, 1000118030) \ + _(XR_TYPE_RENDER_MODEL_PATH_INFO_FB, 1000119000) \ + _(XR_TYPE_RENDER_MODEL_PROPERTIES_FB, 1000119001) \ + _(XR_TYPE_RENDER_MODEL_BUFFER_FB, 1000119002) \ + _(XR_TYPE_RENDER_MODEL_LOAD_INFO_FB, 1000119003) \ + _(XR_TYPE_SYSTEM_RENDER_MODEL_PROPERTIES_FB, 1000119004) \ + _(XR_TYPE_BINDING_MODIFICATIONS_KHR, 1000120000) \ + _(XR_TYPE_VIEW_LOCATE_FOVEATED_RENDERING_VARJO, 1000121000) \ + _(XR_TYPE_FOVEATED_VIEW_CONFIGURATION_VIEW_VARJO, 1000121001) \ + _(XR_TYPE_SYSTEM_FOVEATED_RENDERING_PROPERTIES_VARJO, 1000121002) \ + _(XR_TYPE_COMPOSITION_LAYER_DEPTH_TEST_VARJO, 1000122000) \ + _(XR_TYPE_SYSTEM_MARKER_TRACKING_PROPERTIES_VARJO, 1000124000) \ + _(XR_TYPE_EVENT_DATA_MARKER_TRACKING_UPDATE_VARJO, 1000124001) \ + _(XR_TYPE_MARKER_SPACE_CREATE_INFO_VARJO, 1000124002) \ + _(XR_TYPE_SPATIAL_ANCHOR_PERSISTENCE_INFO_MSFT, 1000142000) \ + _(XR_TYPE_SPATIAL_ANCHOR_FROM_PERSISTED_ANCHOR_CREATE_INFO_MSFT, 1000142001) \ + _(XR_TYPE_SWAPCHAIN_IMAGE_FOVEATION_VULKAN_FB, 1000160000) \ + _(XR_TYPE_SWAPCHAIN_STATE_ANDROID_SURFACE_DIMENSIONS_FB, 1000161000) \ + _(XR_TYPE_SWAPCHAIN_STATE_SAMPLER_OPENGL_ES_FB, 1000162000) \ + _(XR_TYPE_SWAPCHAIN_STATE_SAMPLER_VULKAN_FB, 1000163000) \ + _(XR_TYPE_COMPOSITION_LAYER_SPACE_WARP_INFO_FB, 1000171000) \ + _(XR_TYPE_SYSTEM_SPACE_WARP_PROPERTIES_FB, 1000171001) \ + _(XR_TYPE_DIGITAL_LENS_CONTROL_ALMALENCE, 1000196000) \ + _(XR_TYPE_PASSTHROUGH_KEYBOARD_HANDS_INTENSITY_FB, 1000203002) \ + _(XR_STRUCTURE_TYPE_MAX_ENUM, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrFormFactor(_) \ + _(XR_FORM_FACTOR_HEAD_MOUNTED_DISPLAY, 1) \ + _(XR_FORM_FACTOR_HANDHELD_DISPLAY, 2) \ + _(XR_FORM_FACTOR_MAX_ENUM, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrViewConfigurationType(_) \ + _(XR_VIEW_CONFIGURATION_TYPE_PRIMARY_MONO, 1) \ + _(XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO, 2) \ + _(XR_VIEW_CONFIGURATION_TYPE_PRIMARY_QUAD_VARJO, 1000037000) \ + _(XR_VIEW_CONFIGURATION_TYPE_SECONDARY_MONO_FIRST_PERSON_OBSERVER_MSFT, 1000054000) \ + _(XR_VIEW_CONFIGURATION_TYPE_MAX_ENUM, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrEnvironmentBlendMode(_) \ + _(XR_ENVIRONMENT_BLEND_MODE_OPAQUE, 1) \ + _(XR_ENVIRONMENT_BLEND_MODE_ADDITIVE, 2) \ + _(XR_ENVIRONMENT_BLEND_MODE_ALPHA_BLEND, 3) \ + _(XR_ENVIRONMENT_BLEND_MODE_MAX_ENUM, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrReferenceSpaceType(_) \ + _(XR_REFERENCE_SPACE_TYPE_VIEW, 1) \ + _(XR_REFERENCE_SPACE_TYPE_LOCAL, 2) \ + _(XR_REFERENCE_SPACE_TYPE_STAGE, 3) \ + _(XR_REFERENCE_SPACE_TYPE_UNBOUNDED_MSFT, 1000038000) \ + _(XR_REFERENCE_SPACE_TYPE_COMBINED_EYE_VARJO, 1000121000) \ + _(XR_REFERENCE_SPACE_TYPE_MAX_ENUM, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrActionType(_) \ + _(XR_ACTION_TYPE_BOOLEAN_INPUT, 1) \ + _(XR_ACTION_TYPE_FLOAT_INPUT, 2) \ + _(XR_ACTION_TYPE_VECTOR2F_INPUT, 3) \ + _(XR_ACTION_TYPE_POSE_INPUT, 4) \ + _(XR_ACTION_TYPE_VIBRATION_OUTPUT, 100) \ + _(XR_ACTION_TYPE_MAX_ENUM, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrEyeVisibility(_) \ + _(XR_EYE_VISIBILITY_BOTH, 0) \ + _(XR_EYE_VISIBILITY_LEFT, 1) \ + _(XR_EYE_VISIBILITY_RIGHT, 2) \ + _(XR_EYE_VISIBILITY_MAX_ENUM, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSessionState(_) \ + _(XR_SESSION_STATE_UNKNOWN, 0) \ + _(XR_SESSION_STATE_IDLE, 1) \ + _(XR_SESSION_STATE_READY, 2) \ + _(XR_SESSION_STATE_SYNCHRONIZED, 3) \ + _(XR_SESSION_STATE_VISIBLE, 4) \ + _(XR_SESSION_STATE_FOCUSED, 5) \ + _(XR_SESSION_STATE_STOPPING, 6) \ + _(XR_SESSION_STATE_LOSS_PENDING, 7) \ + _(XR_SESSION_STATE_EXITING, 8) \ + _(XR_SESSION_STATE_MAX_ENUM, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrObjectType(_) \ + _(XR_OBJECT_TYPE_UNKNOWN, 0) \ + _(XR_OBJECT_TYPE_INSTANCE, 1) \ + _(XR_OBJECT_TYPE_SESSION, 2) \ + _(XR_OBJECT_TYPE_SWAPCHAIN, 3) \ + _(XR_OBJECT_TYPE_SPACE, 4) \ + _(XR_OBJECT_TYPE_ACTION_SET, 5) \ + _(XR_OBJECT_TYPE_ACTION, 6) \ + _(XR_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT, 1000019000) \ + _(XR_OBJECT_TYPE_SPATIAL_ANCHOR_MSFT, 1000039000) \ + _(XR_OBJECT_TYPE_HAND_TRACKER_EXT, 1000051000) \ + _(XR_OBJECT_TYPE_SCENE_OBSERVER_MSFT, 1000097000) \ + _(XR_OBJECT_TYPE_SCENE_MSFT, 1000097001) \ + _(XR_OBJECT_TYPE_FACIAL_TRACKER_HTC, 1000104000) \ + _(XR_OBJECT_TYPE_FOVEATION_PROFILE_FB, 1000114000) \ + _(XR_OBJECT_TYPE_TRIANGLE_MESH_FB, 1000117000) \ + _(XR_OBJECT_TYPE_PASSTHROUGH_FB, 1000118000) \ + _(XR_OBJECT_TYPE_PASSTHROUGH_LAYER_FB, 1000118002) \ + _(XR_OBJECT_TYPE_GEOMETRY_INSTANCE_FB, 1000118004) \ + _(XR_OBJECT_TYPE_SPATIAL_ANCHOR_STORE_CONNECTION_MSFT, 1000142000) \ + _(XR_OBJECT_TYPE_MAX_ENUM, 0x7FFFFFFF) + +#define XR_LIST_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) + +#define XR_LIST_ENUM_XrVisibilityMaskTypeKHR(_) \ + _(XR_VISIBILITY_MASK_TYPE_HIDDEN_TRIANGLE_MESH_KHR, 1) \ + _(XR_VISIBILITY_MASK_TYPE_VISIBLE_TRIANGLE_MESH_KHR, 2) \ + _(XR_VISIBILITY_MASK_TYPE_LINE_LOOP_KHR, 3) \ + _(XR_VISIBILITY_MASK_TYPE_MAX_ENUM_KHR, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrPerfSettingsDomainEXT(_) \ + _(XR_PERF_SETTINGS_DOMAIN_CPU_EXT, 1) \ + _(XR_PERF_SETTINGS_DOMAIN_GPU_EXT, 2) \ + _(XR_PERF_SETTINGS_DOMAIN_MAX_ENUM_EXT, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrPerfSettingsSubDomainEXT(_) \ + _(XR_PERF_SETTINGS_SUB_DOMAIN_COMPOSITING_EXT, 1) \ + _(XR_PERF_SETTINGS_SUB_DOMAIN_RENDERING_EXT, 2) \ + _(XR_PERF_SETTINGS_SUB_DOMAIN_THERMAL_EXT, 3) \ + _(XR_PERF_SETTINGS_SUB_DOMAIN_MAX_ENUM_EXT, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrPerfSettingsLevelEXT(_) \ + _(XR_PERF_SETTINGS_LEVEL_POWER_SAVINGS_EXT, 0) \ + _(XR_PERF_SETTINGS_LEVEL_SUSTAINED_LOW_EXT, 25) \ + _(XR_PERF_SETTINGS_LEVEL_SUSTAINED_HIGH_EXT, 50) \ + _(XR_PERF_SETTINGS_LEVEL_BOOST_EXT, 75) \ + _(XR_PERF_SETTINGS_LEVEL_MAX_ENUM_EXT, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrPerfSettingsNotificationLevelEXT(_) \ + _(XR_PERF_SETTINGS_NOTIF_LEVEL_NORMAL_EXT, 0) \ + _(XR_PERF_SETTINGS_NOTIF_LEVEL_WARNING_EXT, 25) \ + _(XR_PERF_SETTINGS_NOTIF_LEVEL_IMPAIRED_EXT, 75) \ + _(XR_PERF_SETTINGS_NOTIFICATION_LEVEL_MAX_ENUM_EXT, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrBlendFactorFB(_) \ + _(XR_BLEND_FACTOR_ZERO_FB, 0) \ + _(XR_BLEND_FACTOR_ONE_FB, 1) \ + _(XR_BLEND_FACTOR_SRC_ALPHA_FB, 2) \ + _(XR_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA_FB, 3) \ + _(XR_BLEND_FACTOR_DST_ALPHA_FB, 4) \ + _(XR_BLEND_FACTOR_ONE_MINUS_DST_ALPHA_FB, 5) \ + _(XR_BLEND_FACTOR_MAX_ENUM_FB, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSpatialGraphNodeTypeMSFT(_) \ + _(XR_SPATIAL_GRAPH_NODE_TYPE_STATIC_MSFT, 1) \ + _(XR_SPATIAL_GRAPH_NODE_TYPE_DYNAMIC_MSFT, 2) \ + _(XR_SPATIAL_GRAPH_NODE_TYPE_MAX_ENUM_MSFT, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrHandEXT(_) \ + _(XR_HAND_LEFT_EXT, 1) \ + _(XR_HAND_RIGHT_EXT, 2) \ + _(XR_HAND_MAX_ENUM_EXT, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrHandJointEXT(_) \ + _(XR_HAND_JOINT_PALM_EXT, 0) \ + _(XR_HAND_JOINT_WRIST_EXT, 1) \ + _(XR_HAND_JOINT_THUMB_METACARPAL_EXT, 2) \ + _(XR_HAND_JOINT_THUMB_PROXIMAL_EXT, 3) \ + _(XR_HAND_JOINT_THUMB_DISTAL_EXT, 4) \ + _(XR_HAND_JOINT_THUMB_TIP_EXT, 5) \ + _(XR_HAND_JOINT_INDEX_METACARPAL_EXT, 6) \ + _(XR_HAND_JOINT_INDEX_PROXIMAL_EXT, 7) \ + _(XR_HAND_JOINT_INDEX_INTERMEDIATE_EXT, 8) \ + _(XR_HAND_JOINT_INDEX_DISTAL_EXT, 9) \ + _(XR_HAND_JOINT_INDEX_TIP_EXT, 10) \ + _(XR_HAND_JOINT_MIDDLE_METACARPAL_EXT, 11) \ + _(XR_HAND_JOINT_MIDDLE_PROXIMAL_EXT, 12) \ + _(XR_HAND_JOINT_MIDDLE_INTERMEDIATE_EXT, 13) \ + _(XR_HAND_JOINT_MIDDLE_DISTAL_EXT, 14) \ + _(XR_HAND_JOINT_MIDDLE_TIP_EXT, 15) \ + _(XR_HAND_JOINT_RING_METACARPAL_EXT, 16) \ + _(XR_HAND_JOINT_RING_PROXIMAL_EXT, 17) \ + _(XR_HAND_JOINT_RING_INTERMEDIATE_EXT, 18) \ + _(XR_HAND_JOINT_RING_DISTAL_EXT, 19) \ + _(XR_HAND_JOINT_RING_TIP_EXT, 20) \ + _(XR_HAND_JOINT_LITTLE_METACARPAL_EXT, 21) \ + _(XR_HAND_JOINT_LITTLE_PROXIMAL_EXT, 22) \ + _(XR_HAND_JOINT_LITTLE_INTERMEDIATE_EXT, 23) \ + _(XR_HAND_JOINT_LITTLE_DISTAL_EXT, 24) \ + _(XR_HAND_JOINT_LITTLE_TIP_EXT, 25) \ + _(XR_HAND_JOINT_MAX_ENUM_EXT, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrHandJointSetEXT(_) \ + _(XR_HAND_JOINT_SET_DEFAULT_EXT, 0) \ + _(XR_HAND_JOINT_SET_MAX_ENUM_EXT, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrHandPoseTypeMSFT(_) \ + _(XR_HAND_POSE_TYPE_TRACKED_MSFT, 0) \ + _(XR_HAND_POSE_TYPE_REFERENCE_OPEN_PALM_MSFT, 1) \ + _(XR_HAND_POSE_TYPE_MAX_ENUM_MSFT, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrReprojectionModeMSFT(_) \ + _(XR_REPROJECTION_MODE_DEPTH_MSFT, 1) \ + _(XR_REPROJECTION_MODE_PLANAR_FROM_DEPTH_MSFT, 2) \ + _(XR_REPROJECTION_MODE_PLANAR_MANUAL_MSFT, 3) \ + _(XR_REPROJECTION_MODE_ORIENTATION_ONLY_MSFT, 4) \ + _(XR_REPROJECTION_MODE_MAX_ENUM_MSFT, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrHandJointsMotionRangeEXT(_) \ + _(XR_HAND_JOINTS_MOTION_RANGE_UNOBSTRUCTED_EXT, 1) \ + _(XR_HAND_JOINTS_MOTION_RANGE_CONFORMING_TO_CONTROLLER_EXT, 2) \ + _(XR_HAND_JOINTS_MOTION_RANGE_MAX_ENUM_EXT, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSceneComputeFeatureMSFT(_) \ + _(XR_SCENE_COMPUTE_FEATURE_PLANE_MSFT, 1) \ + _(XR_SCENE_COMPUTE_FEATURE_PLANE_MESH_MSFT, 2) \ + _(XR_SCENE_COMPUTE_FEATURE_VISUAL_MESH_MSFT, 3) \ + _(XR_SCENE_COMPUTE_FEATURE_COLLIDER_MESH_MSFT, 4) \ + _(XR_SCENE_COMPUTE_FEATURE_SERIALIZE_SCENE_MSFT, 1000098000) \ + _(XR_SCENE_COMPUTE_FEATURE_MAX_ENUM_MSFT, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSceneComputeConsistencyMSFT(_) \ + _(XR_SCENE_COMPUTE_CONSISTENCY_SNAPSHOT_COMPLETE_MSFT, 1) \ + _(XR_SCENE_COMPUTE_CONSISTENCY_SNAPSHOT_INCOMPLETE_FAST_MSFT, 2) \ + _(XR_SCENE_COMPUTE_CONSISTENCY_OCCLUSION_OPTIMIZED_MSFT, 3) \ + _(XR_SCENE_COMPUTE_CONSISTENCY_MAX_ENUM_MSFT, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrMeshComputeLodMSFT(_) \ + _(XR_MESH_COMPUTE_LOD_COARSE_MSFT, 1) \ + _(XR_MESH_COMPUTE_LOD_MEDIUM_MSFT, 2) \ + _(XR_MESH_COMPUTE_LOD_FINE_MSFT, 3) \ + _(XR_MESH_COMPUTE_LOD_UNLIMITED_MSFT, 4) \ + _(XR_MESH_COMPUTE_LOD_MAX_ENUM_MSFT, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSceneComponentTypeMSFT(_) \ + _(XR_SCENE_COMPONENT_TYPE_INVALID_MSFT, -1) \ + _(XR_SCENE_COMPONENT_TYPE_OBJECT_MSFT, 1) \ + _(XR_SCENE_COMPONENT_TYPE_PLANE_MSFT, 2) \ + _(XR_SCENE_COMPONENT_TYPE_VISUAL_MESH_MSFT, 3) \ + _(XR_SCENE_COMPONENT_TYPE_COLLIDER_MESH_MSFT, 4) \ + _(XR_SCENE_COMPONENT_TYPE_SERIALIZED_SCENE_FRAGMENT_MSFT, 1000098000) \ + _(XR_SCENE_COMPONENT_TYPE_MAX_ENUM_MSFT, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSceneObjectTypeMSFT(_) \ + _(XR_SCENE_OBJECT_TYPE_UNCATEGORIZED_MSFT, -1) \ + _(XR_SCENE_OBJECT_TYPE_BACKGROUND_MSFT, 1) \ + _(XR_SCENE_OBJECT_TYPE_WALL_MSFT, 2) \ + _(XR_SCENE_OBJECT_TYPE_FLOOR_MSFT, 3) \ + _(XR_SCENE_OBJECT_TYPE_CEILING_MSFT, 4) \ + _(XR_SCENE_OBJECT_TYPE_PLATFORM_MSFT, 5) \ + _(XR_SCENE_OBJECT_TYPE_INFERRED_MSFT, 6) \ + _(XR_SCENE_OBJECT_TYPE_MAX_ENUM_MSFT, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrScenePlaneAlignmentTypeMSFT(_) \ + _(XR_SCENE_PLANE_ALIGNMENT_TYPE_NON_ORTHOGONAL_MSFT, 0) \ + _(XR_SCENE_PLANE_ALIGNMENT_TYPE_HORIZONTAL_MSFT, 1) \ + _(XR_SCENE_PLANE_ALIGNMENT_TYPE_VERTICAL_MSFT, 2) \ + _(XR_SCENE_PLANE_ALIGNMENT_TYPE_MAX_ENUM_MSFT, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSceneComputeStateMSFT(_) \ + _(XR_SCENE_COMPUTE_STATE_NONE_MSFT, 0) \ + _(XR_SCENE_COMPUTE_STATE_UPDATING_MSFT, 1) \ + _(XR_SCENE_COMPUTE_STATE_COMPLETED_MSFT, 2) \ + _(XR_SCENE_COMPUTE_STATE_COMPLETED_WITH_ERROR_MSFT, 3) \ + _(XR_SCENE_COMPUTE_STATE_MAX_ENUM_MSFT, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrEyeExpressionHTC(_) \ + _(XR_EYE_EXPRESSION_LEFT_BLINK_HTC, 0) \ + _(XR_EYE_EXPRESSION_LEFT_WIDE_HTC, 1) \ + _(XR_EYE_EXPRESSION_RIGHT_BLINK_HTC, 2) \ + _(XR_EYE_EXPRESSION_RIGHT_WIDE_HTC, 3) \ + _(XR_EYE_EXPRESSION_LEFT_SQUEEZE_HTC, 4) \ + _(XR_EYE_EXPRESSION_RIGHT_SQUEEZE_HTC, 5) \ + _(XR_EYE_EXPRESSION_LEFT_DOWN_HTC, 6) \ + _(XR_EYE_EXPRESSION_RIGHT_DOWN_HTC, 7) \ + _(XR_EYE_EXPRESSION_LEFT_OUT_HTC, 8) \ + _(XR_EYE_EXPRESSION_RIGHT_IN_HTC, 9) \ + _(XR_EYE_EXPRESSION_LEFT_IN_HTC, 10) \ + _(XR_EYE_EXPRESSION_RIGHT_OUT_HTC, 11) \ + _(XR_EYE_EXPRESSION_LEFT_UP_HTC, 12) \ + _(XR_EYE_EXPRESSION_RIGHT_UP_HTC, 13) \ + _(XR_EYE_EXPRESSION_MAX_ENUM_HTC, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrLipExpressionHTC(_) \ + _(XR_LIP_EXPRESSION_JAW_RIGHT_HTC, 0) \ + _(XR_LIP_EXPRESSION_JAW_LEFT_HTC, 1) \ + _(XR_LIP_EXPRESSION_JAW_FORWARD_HTC, 2) \ + _(XR_LIP_EXPRESSION_JAW_OPEN_HTC, 3) \ + _(XR_LIP_EXPRESSION_MOUTH_APE_SHAPE_HTC, 4) \ + _(XR_LIP_EXPRESSION_MOUTH_UPPER_RIGHT_HTC, 5) \ + _(XR_LIP_EXPRESSION_MOUTH_UPPER_LEFT_HTC, 6) \ + _(XR_LIP_EXPRESSION_MOUTH_LOWER_RIGHT_HTC, 7) \ + _(XR_LIP_EXPRESSION_MOUTH_LOWER_LEFT_HTC, 8) \ + _(XR_LIP_EXPRESSION_MOUTH_UPPER_OVERTURN_HTC, 9) \ + _(XR_LIP_EXPRESSION_MOUTH_LOWER_OVERTURN_HTC, 10) \ + _(XR_LIP_EXPRESSION_MOUTH_POUT_HTC, 11) \ + _(XR_LIP_EXPRESSION_MOUTH_SMILE_RIGHT_HTC, 12) \ + _(XR_LIP_EXPRESSION_MOUTH_SMILE_LEFT_HTC, 13) \ + _(XR_LIP_EXPRESSION_MOUTH_SAD_RIGHT_HTC, 14) \ + _(XR_LIP_EXPRESSION_MOUTH_SAD_LEFT_HTC, 15) \ + _(XR_LIP_EXPRESSION_CHEEK_PUFF_RIGHT_HTC, 16) \ + _(XR_LIP_EXPRESSION_CHEEK_PUFF_LEFT_HTC, 17) \ + _(XR_LIP_EXPRESSION_CHEEK_SUCK_HTC, 18) \ + _(XR_LIP_EXPRESSION_MOUTH_UPPER_UPRIGHT_HTC, 19) \ + _(XR_LIP_EXPRESSION_MOUTH_UPPER_UPLEFT_HTC, 20) \ + _(XR_LIP_EXPRESSION_MOUTH_LOWER_DOWNRIGHT_HTC, 21) \ + _(XR_LIP_EXPRESSION_MOUTH_LOWER_DOWNLEFT_HTC, 22) \ + _(XR_LIP_EXPRESSION_MOUTH_UPPER_INSIDE_HTC, 23) \ + _(XR_LIP_EXPRESSION_MOUTH_LOWER_INSIDE_HTC, 24) \ + _(XR_LIP_EXPRESSION_MOUTH_LOWER_OVERLAY_HTC, 25) \ + _(XR_LIP_EXPRESSION_TONGUE_LONGSTEP1_HTC, 26) \ + _(XR_LIP_EXPRESSION_TONGUE_LEFT_HTC, 27) \ + _(XR_LIP_EXPRESSION_TONGUE_RIGHT_HTC, 28) \ + _(XR_LIP_EXPRESSION_TONGUE_UP_HTC, 29) \ + _(XR_LIP_EXPRESSION_TONGUE_DOWN_HTC, 30) \ + _(XR_LIP_EXPRESSION_TONGUE_ROLL_HTC, 31) \ + _(XR_LIP_EXPRESSION_TONGUE_LONGSTEP2_HTC, 32) \ + _(XR_LIP_EXPRESSION_TONGUE_UPRIGHT_MORPH_HTC, 33) \ + _(XR_LIP_EXPRESSION_TONGUE_UPLEFT_MORPH_HTC, 34) \ + _(XR_LIP_EXPRESSION_TONGUE_DOWNRIGHT_MORPH_HTC, 35) \ + _(XR_LIP_EXPRESSION_TONGUE_DOWNLEFT_MORPH_HTC, 36) \ + _(XR_LIP_EXPRESSION_MAX_ENUM_HTC, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrFacialTrackingTypeHTC(_) \ + _(XR_FACIAL_TRACKING_TYPE_EYE_DEFAULT_HTC, 1) \ + _(XR_FACIAL_TRACKING_TYPE_LIP_DEFAULT_HTC, 2) \ + _(XR_FACIAL_TRACKING_TYPE_MAX_ENUM_HTC, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrColorSpaceFB(_) \ + _(XR_COLOR_SPACE_UNMANAGED_FB, 0) \ + _(XR_COLOR_SPACE_REC2020_FB, 1) \ + _(XR_COLOR_SPACE_REC709_FB, 2) \ + _(XR_COLOR_SPACE_RIFT_CV1_FB, 3) \ + _(XR_COLOR_SPACE_RIFT_S_FB, 4) \ + _(XR_COLOR_SPACE_QUEST_FB, 5) \ + _(XR_COLOR_SPACE_P3_FB, 6) \ + _(XR_COLOR_SPACE_ADOBE_RGB_FB, 7) \ + _(XR_COLOR_SPACE_MAX_ENUM_FB, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrFoveationLevelFB(_) \ + _(XR_FOVEATION_LEVEL_NONE_FB, 0) \ + _(XR_FOVEATION_LEVEL_LOW_FB, 1) \ + _(XR_FOVEATION_LEVEL_MEDIUM_FB, 2) \ + _(XR_FOVEATION_LEVEL_HIGH_FB, 3) \ + _(XR_FOVEATION_LEVEL_MAX_ENUM_FB, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrFoveationDynamicFB(_) \ + _(XR_FOVEATION_DYNAMIC_DISABLED_FB, 0) \ + _(XR_FOVEATION_DYNAMIC_LEVEL_ENABLED_FB, 1) \ + _(XR_FOVEATION_DYNAMIC_MAX_ENUM_FB, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrWindingOrderFB(_) \ + _(XR_WINDING_ORDER_UNKNOWN_FB, 0) \ + _(XR_WINDING_ORDER_CW_FB, 1) \ + _(XR_WINDING_ORDER_CCW_FB, 2) \ + _(XR_WINDING_ORDER_MAX_ENUM_FB, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrPassthroughLayerPurposeFB(_) \ + _(XR_PASSTHROUGH_LAYER_PURPOSE_RECONSTRUCTION_FB, 0) \ + _(XR_PASSTHROUGH_LAYER_PURPOSE_PROJECTED_FB, 1) \ + _(XR_PASSTHROUGH_LAYER_PURPOSE_TRACKED_KEYBOARD_HANDS_FB, 1000203001) \ + _(XR_PASSTHROUGH_LAYER_PURPOSE_MAX_ENUM_FB, 0x7FFFFFFF) + +#define XR_LIST_BITS_XrInstanceCreateFlags(_) + +#define XR_LIST_BITS_XrSessionCreateFlags(_) + +#define XR_LIST_BITS_XrSpaceVelocityFlags(_) \ + _(XR_SPACE_VELOCITY_LINEAR_VALID_BIT, 0x00000001) \ + _(XR_SPACE_VELOCITY_ANGULAR_VALID_BIT, 0x00000002) \ + +#define XR_LIST_BITS_XrSpaceLocationFlags(_) \ + _(XR_SPACE_LOCATION_ORIENTATION_VALID_BIT, 0x00000001) \ + _(XR_SPACE_LOCATION_POSITION_VALID_BIT, 0x00000002) \ + _(XR_SPACE_LOCATION_ORIENTATION_TRACKED_BIT, 0x00000004) \ + _(XR_SPACE_LOCATION_POSITION_TRACKED_BIT, 0x00000008) \ + +#define XR_LIST_BITS_XrSwapchainCreateFlags(_) \ + _(XR_SWAPCHAIN_CREATE_PROTECTED_CONTENT_BIT, 0x00000001) \ + _(XR_SWAPCHAIN_CREATE_STATIC_IMAGE_BIT, 0x00000002) \ + +#define XR_LIST_BITS_XrSwapchainUsageFlags(_) \ + _(XR_SWAPCHAIN_USAGE_COLOR_ATTACHMENT_BIT, 0x00000001) \ + _(XR_SWAPCHAIN_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, 0x00000002) \ + _(XR_SWAPCHAIN_USAGE_UNORDERED_ACCESS_BIT, 0x00000004) \ + _(XR_SWAPCHAIN_USAGE_TRANSFER_SRC_BIT, 0x00000008) \ + _(XR_SWAPCHAIN_USAGE_TRANSFER_DST_BIT, 0x00000010) \ + _(XR_SWAPCHAIN_USAGE_SAMPLED_BIT, 0x00000020) \ + _(XR_SWAPCHAIN_USAGE_MUTABLE_FORMAT_BIT, 0x00000040) \ + _(XR_SWAPCHAIN_USAGE_INPUT_ATTACHMENT_BIT_MND, 0x00000080) \ + _(XR_SWAPCHAIN_USAGE_INPUT_ATTACHMENT_BIT_KHR, XR_SWAPCHAIN_USAGE_INPUT_ATTACHMENT_BIT_MND) \ + +#define XR_LIST_BITS_XrCompositionLayerFlags(_) \ + _(XR_COMPOSITION_LAYER_CORRECT_CHROMATIC_ABERRATION_BIT, 0x00000001) \ + _(XR_COMPOSITION_LAYER_BLEND_TEXTURE_SOURCE_ALPHA_BIT, 0x00000002) \ + _(XR_COMPOSITION_LAYER_UNPREMULTIPLIED_ALPHA_BIT, 0x00000004) \ + +#define XR_LIST_BITS_XrViewStateFlags(_) \ + _(XR_VIEW_STATE_ORIENTATION_VALID_BIT, 0x00000001) \ + _(XR_VIEW_STATE_POSITION_VALID_BIT, 0x00000002) \ + _(XR_VIEW_STATE_ORIENTATION_TRACKED_BIT, 0x00000004) \ + _(XR_VIEW_STATE_POSITION_TRACKED_BIT, 0x00000008) \ + +#define XR_LIST_BITS_XrInputSourceLocalizedNameFlags(_) \ + _(XR_INPUT_SOURCE_LOCALIZED_NAME_USER_PATH_BIT, 0x00000001) \ + _(XR_INPUT_SOURCE_LOCALIZED_NAME_INTERACTION_PROFILE_BIT, 0x00000002) \ + _(XR_INPUT_SOURCE_LOCALIZED_NAME_COMPONENT_BIT, 0x00000004) \ + +#define XR_LIST_BITS_XrVulkanInstanceCreateFlagsKHR(_) + +#define XR_LIST_BITS_XrVulkanDeviceCreateFlagsKHR(_) + +#define XR_LIST_BITS_XrDebugUtilsMessageSeverityFlagsEXT(_) \ + _(XR_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT, 0x00000001) \ + _(XR_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT, 0x00000010) \ + _(XR_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT, 0x00000100) \ + _(XR_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT, 0x00001000) \ + +#define XR_LIST_BITS_XrDebugUtilsMessageTypeFlagsEXT(_) \ + _(XR_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT, 0x00000001) \ + _(XR_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT, 0x00000002) \ + _(XR_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT, 0x00000004) \ + _(XR_DEBUG_UTILS_MESSAGE_TYPE_CONFORMANCE_BIT_EXT, 0x00000008) \ + +#define XR_LIST_BITS_XrOverlaySessionCreateFlagsEXTX(_) + +#define XR_LIST_BITS_XrOverlayMainSessionFlagsEXTX(_) \ + _(XR_OVERLAY_MAIN_SESSION_ENABLED_COMPOSITION_LAYER_INFO_DEPTH_BIT_EXTX, 0x00000001) \ + +#define XR_LIST_BITS_XrCompositionLayerImageLayoutFlagsFB(_) \ + _(XR_COMPOSITION_LAYER_IMAGE_LAYOUT_VERTICAL_FLIP_BIT_FB, 0x00000001) \ + +#define XR_LIST_BITS_XrAndroidSurfaceSwapchainFlagsFB(_) \ + _(XR_ANDROID_SURFACE_SWAPCHAIN_SYNCHRONOUS_BIT_FB, 0x00000001) \ + _(XR_ANDROID_SURFACE_SWAPCHAIN_USE_TIMESTAMPS_BIT_FB, 0x00000002) \ + +#define XR_LIST_BITS_XrCompositionLayerSecureContentFlagsFB(_) \ + _(XR_COMPOSITION_LAYER_SECURE_CONTENT_EXCLUDE_LAYER_BIT_FB, 0x00000001) \ + _(XR_COMPOSITION_LAYER_SECURE_CONTENT_REPLACE_LAYER_BIT_FB, 0x00000002) \ + +#define XR_LIST_BITS_XrHandTrackingAimFlagsFB(_) \ + _(XR_HAND_TRACKING_AIM_COMPUTED_BIT_FB, 0x00000001) \ + _(XR_HAND_TRACKING_AIM_VALID_BIT_FB, 0x00000002) \ + _(XR_HAND_TRACKING_AIM_INDEX_PINCHING_BIT_FB, 0x00000004) \ + _(XR_HAND_TRACKING_AIM_MIDDLE_PINCHING_BIT_FB, 0x00000008) \ + _(XR_HAND_TRACKING_AIM_RING_PINCHING_BIT_FB, 0x00000010) \ + _(XR_HAND_TRACKING_AIM_LITTLE_PINCHING_BIT_FB, 0x00000020) \ + _(XR_HAND_TRACKING_AIM_SYSTEM_GESTURE_BIT_FB, 0x00000040) \ + _(XR_HAND_TRACKING_AIM_DOMINANT_HAND_BIT_FB, 0x00000080) \ + _(XR_HAND_TRACKING_AIM_MENU_PRESSED_BIT_FB, 0x00000100) \ + +#define XR_LIST_BITS_XrSwapchainCreateFoveationFlagsFB(_) \ + _(XR_SWAPCHAIN_CREATE_FOVEATION_SCALED_BIN_BIT_FB, 0x00000001) \ + _(XR_SWAPCHAIN_CREATE_FOVEATION_FRAGMENT_DENSITY_MAP_BIT_FB, 0x00000002) \ + +#define XR_LIST_BITS_XrSwapchainStateFoveationFlagsFB(_) + +#define XR_LIST_BITS_XrKeyboardTrackingFlagsFB(_) \ + _(XR_KEYBOARD_TRACKING_EXISTS_BIT_FB, 0x00000001) \ + _(XR_KEYBOARD_TRACKING_LOCAL_BIT_FB, 0x00000002) \ + _(XR_KEYBOARD_TRACKING_REMOTE_BIT_FB, 0x00000004) \ + _(XR_KEYBOARD_TRACKING_CONNECTED_BIT_FB, 0x00000008) \ + +#define XR_LIST_BITS_XrKeyboardTrackingQueryFlagsFB(_) \ + _(XR_KEYBOARD_TRACKING_QUERY_LOCAL_BIT_FB, 0x00000002) \ + _(XR_KEYBOARD_TRACKING_QUERY_REMOTE_BIT_FB, 0x00000004) \ + +#define XR_LIST_BITS_XrTriangleMeshFlagsFB(_) \ + _(XR_TRIANGLE_MESH_MUTABLE_BIT_FB, 0x00000001) \ + +#define XR_LIST_BITS_XrPassthroughFlagsFB(_) \ + _(XR_PASSTHROUGH_IS_RUNNING_AT_CREATION_BIT_FB, 0x00000001) \ + +#define XR_LIST_BITS_XrPassthroughStateChangedFlagsFB(_) \ + _(XR_PASSTHROUGH_STATE_CHANGED_REINIT_REQUIRED_BIT_FB, 0x00000001) \ + _(XR_PASSTHROUGH_STATE_CHANGED_NON_RECOVERABLE_ERROR_BIT_FB, 0x00000002) \ + _(XR_PASSTHROUGH_STATE_CHANGED_RECOVERABLE_ERROR_BIT_FB, 0x00000004) \ + _(XR_PASSTHROUGH_STATE_CHANGED_RESTORED_ERROR_BIT_FB, 0x00000008) \ + +#define XR_LIST_BITS_XrRenderModelFlagsFB(_) + +#define XR_LIST_BITS_XrCompositionLayerSpaceWarpInfoFlagsFB(_) + +#define XR_LIST_BITS_XrDigitalLensControlFlagsALMALENCE(_) \ + _(XR_DIGITAL_LENS_CONTROL_PROCESSING_DISABLE_BIT_ALMALENCE, 0x00000001) \ + +#define XR_LIST_STRUCT_XrApiLayerProperties(_) \ + _(type) \ + _(next) \ + _(layerName) \ + _(specVersion) \ + _(layerVersion) \ + _(description) \ + +#define XR_LIST_STRUCT_XrExtensionProperties(_) \ + _(type) \ + _(next) \ + _(extensionName) \ + _(extensionVersion) \ + +#define XR_LIST_STRUCT_XrApplicationInfo(_) \ + _(applicationName) \ + _(applicationVersion) \ + _(engineName) \ + _(engineVersion) \ + _(apiVersion) \ + +#define XR_LIST_STRUCT_XrInstanceCreateInfo(_) \ + _(type) \ + _(next) \ + _(createFlags) \ + _(applicationInfo) \ + _(enabledApiLayerCount) \ + _(enabledApiLayerNames) \ + _(enabledExtensionCount) \ + _(enabledExtensionNames) \ + +#define XR_LIST_STRUCT_XrInstanceProperties(_) \ + _(type) \ + _(next) \ + _(runtimeVersion) \ + _(runtimeName) \ + +#define XR_LIST_STRUCT_XrEventDataBuffer(_) \ + _(type) \ + _(next) \ + _(varying) \ + +#define XR_LIST_STRUCT_XrSystemGetInfo(_) \ + _(type) \ + _(next) \ + _(formFactor) \ + +#define XR_LIST_STRUCT_XrSystemGraphicsProperties(_) \ + _(maxSwapchainImageHeight) \ + _(maxSwapchainImageWidth) \ + _(maxLayerCount) \ + +#define XR_LIST_STRUCT_XrSystemTrackingProperties(_) \ + _(orientationTracking) \ + _(positionTracking) \ + +#define XR_LIST_STRUCT_XrSystemProperties(_) \ + _(type) \ + _(next) \ + _(systemId) \ + _(vendorId) \ + _(systemName) \ + _(graphicsProperties) \ + _(trackingProperties) \ + +#define XR_LIST_STRUCT_XrSessionCreateInfo(_) \ + _(type) \ + _(next) \ + _(createFlags) \ + _(systemId) \ + +#define XR_LIST_STRUCT_XrVector3f(_) \ + _(x) \ + _(y) \ + _(z) \ + +#define XR_LIST_STRUCT_XrSpaceVelocity(_) \ + _(type) \ + _(next) \ + _(velocityFlags) \ + _(linearVelocity) \ + _(angularVelocity) \ + +#define XR_LIST_STRUCT_XrQuaternionf(_) \ + _(x) \ + _(y) \ + _(z) \ + _(w) \ + +#define XR_LIST_STRUCT_XrPosef(_) \ + _(orientation) \ + _(position) \ + +#define XR_LIST_STRUCT_XrReferenceSpaceCreateInfo(_) \ + _(type) \ + _(next) \ + _(referenceSpaceType) \ + _(poseInReferenceSpace) \ + +#define XR_LIST_STRUCT_XrExtent2Df(_) \ + _(width) \ + _(height) \ + +#define XR_LIST_STRUCT_XrActionSpaceCreateInfo(_) \ + _(type) \ + _(next) \ + _(action) \ + _(subactionPath) \ + _(poseInActionSpace) \ + +#define XR_LIST_STRUCT_XrSpaceLocation(_) \ + _(type) \ + _(next) \ + _(locationFlags) \ + _(pose) \ + +#define XR_LIST_STRUCT_XrViewConfigurationProperties(_) \ + _(type) \ + _(next) \ + _(viewConfigurationType) \ + _(fovMutable) \ + +#define XR_LIST_STRUCT_XrViewConfigurationView(_) \ + _(type) \ + _(next) \ + _(recommendedImageRectWidth) \ + _(maxImageRectWidth) \ + _(recommendedImageRectHeight) \ + _(maxImageRectHeight) \ + _(recommendedSwapchainSampleCount) \ + _(maxSwapchainSampleCount) \ + +#define XR_LIST_STRUCT_XrSwapchainCreateInfo(_) \ + _(type) \ + _(next) \ + _(createFlags) \ + _(usageFlags) \ + _(format) \ + _(sampleCount) \ + _(width) \ + _(height) \ + _(faceCount) \ + _(arraySize) \ + _(mipCount) \ + +#define XR_LIST_STRUCT_XrSwapchainImageBaseHeader(_) \ + _(type) \ + _(next) \ + +#define XR_LIST_STRUCT_XrSwapchainImageAcquireInfo(_) \ + _(type) \ + _(next) \ + +#define XR_LIST_STRUCT_XrSwapchainImageWaitInfo(_) \ + _(type) \ + _(next) \ + _(timeout) \ + +#define XR_LIST_STRUCT_XrSwapchainImageReleaseInfo(_) \ + _(type) \ + _(next) \ + +#define XR_LIST_STRUCT_XrSessionBeginInfo(_) \ + _(type) \ + _(next) \ + _(primaryViewConfigurationType) \ + +#define XR_LIST_STRUCT_XrFrameWaitInfo(_) \ + _(type) \ + _(next) \ + +#define XR_LIST_STRUCT_XrFrameState(_) \ + _(type) \ + _(next) \ + _(predictedDisplayTime) \ + _(predictedDisplayPeriod) \ + _(shouldRender) \ + +#define XR_LIST_STRUCT_XrFrameBeginInfo(_) \ + _(type) \ + _(next) \ + +#define XR_LIST_STRUCT_XrCompositionLayerBaseHeader(_) \ + _(type) \ + _(next) \ + _(layerFlags) \ + _(space) \ + +#define XR_LIST_STRUCT_XrFrameEndInfo(_) \ + _(type) \ + _(next) \ + _(displayTime) \ + _(environmentBlendMode) \ + _(layerCount) \ + _(layers) \ + +#define XR_LIST_STRUCT_XrViewLocateInfo(_) \ + _(type) \ + _(next) \ + _(viewConfigurationType) \ + _(displayTime) \ + _(space) \ + +#define XR_LIST_STRUCT_XrViewState(_) \ + _(type) \ + _(next) \ + _(viewStateFlags) \ + +#define XR_LIST_STRUCT_XrFovf(_) \ + _(angleLeft) \ + _(angleRight) \ + _(angleUp) \ + _(angleDown) \ + +#define XR_LIST_STRUCT_XrView(_) \ + _(type) \ + _(next) \ + _(pose) \ + _(fov) \ + +#define XR_LIST_STRUCT_XrActionSetCreateInfo(_) \ + _(type) \ + _(next) \ + _(actionSetName) \ + _(localizedActionSetName) \ + _(priority) \ + +#define XR_LIST_STRUCT_XrActionCreateInfo(_) \ + _(type) \ + _(next) \ + _(actionName) \ + _(actionType) \ + _(countSubactionPaths) \ + _(subactionPaths) \ + _(localizedActionName) \ + +#define XR_LIST_STRUCT_XrActionSuggestedBinding(_) \ + _(action) \ + _(binding) \ + +#define XR_LIST_STRUCT_XrInteractionProfileSuggestedBinding(_) \ + _(type) \ + _(next) \ + _(interactionProfile) \ + _(countSuggestedBindings) \ + _(suggestedBindings) \ + +#define XR_LIST_STRUCT_XrSessionActionSetsAttachInfo(_) \ + _(type) \ + _(next) \ + _(countActionSets) \ + _(actionSets) \ + +#define XR_LIST_STRUCT_XrInteractionProfileState(_) \ + _(type) \ + _(next) \ + _(interactionProfile) \ + +#define XR_LIST_STRUCT_XrActionStateGetInfo(_) \ + _(type) \ + _(next) \ + _(action) \ + _(subactionPath) \ + +#define XR_LIST_STRUCT_XrActionStateBoolean(_) \ + _(type) \ + _(next) \ + _(currentState) \ + _(changedSinceLastSync) \ + _(lastChangeTime) \ + _(isActive) \ + +#define XR_LIST_STRUCT_XrActionStateFloat(_) \ + _(type) \ + _(next) \ + _(currentState) \ + _(changedSinceLastSync) \ + _(lastChangeTime) \ + _(isActive) \ + +#define XR_LIST_STRUCT_XrVector2f(_) \ + _(x) \ + _(y) \ + +#define XR_LIST_STRUCT_XrActionStateVector2f(_) \ + _(type) \ + _(next) \ + _(currentState) \ + _(changedSinceLastSync) \ + _(lastChangeTime) \ + _(isActive) \ + +#define XR_LIST_STRUCT_XrActionStatePose(_) \ + _(type) \ + _(next) \ + _(isActive) \ + +#define XR_LIST_STRUCT_XrActiveActionSet(_) \ + _(actionSet) \ + _(subactionPath) \ + +#define XR_LIST_STRUCT_XrActionsSyncInfo(_) \ + _(type) \ + _(next) \ + _(countActiveActionSets) \ + _(activeActionSets) \ + +#define XR_LIST_STRUCT_XrBoundSourcesForActionEnumerateInfo(_) \ + _(type) \ + _(next) \ + _(action) \ + +#define XR_LIST_STRUCT_XrInputSourceLocalizedNameGetInfo(_) \ + _(type) \ + _(next) \ + _(sourcePath) \ + _(whichComponents) \ + +#define XR_LIST_STRUCT_XrHapticActionInfo(_) \ + _(type) \ + _(next) \ + _(action) \ + _(subactionPath) \ + +#define XR_LIST_STRUCT_XrHapticBaseHeader(_) \ + _(type) \ + _(next) \ + +#define XR_LIST_STRUCT_XrBaseInStructure(_) \ + _(type) \ + _(next) \ + +#define XR_LIST_STRUCT_XrBaseOutStructure(_) \ + _(type) \ + _(next) \ + +#define XR_LIST_STRUCT_XrOffset2Di(_) \ + _(x) \ + _(y) \ + +#define XR_LIST_STRUCT_XrExtent2Di(_) \ + _(width) \ + _(height) \ + +#define XR_LIST_STRUCT_XrRect2Di(_) \ + _(offset) \ + _(extent) \ + +#define XR_LIST_STRUCT_XrSwapchainSubImage(_) \ + _(swapchain) \ + _(imageRect) \ + _(imageArrayIndex) \ + +#define XR_LIST_STRUCT_XrCompositionLayerProjectionView(_) \ + _(type) \ + _(next) \ + _(pose) \ + _(fov) \ + _(subImage) \ + +#define XR_LIST_STRUCT_XrCompositionLayerProjection(_) \ + _(type) \ + _(next) \ + _(layerFlags) \ + _(space) \ + _(viewCount) \ + _(views) \ + +#define XR_LIST_STRUCT_XrCompositionLayerQuad(_) \ + _(type) \ + _(next) \ + _(layerFlags) \ + _(space) \ + _(eyeVisibility) \ + _(subImage) \ + _(pose) \ + _(size) \ + +#define XR_LIST_STRUCT_XrEventDataBaseHeader(_) \ + _(type) \ + _(next) \ + +#define XR_LIST_STRUCT_XrEventDataEventsLost(_) \ + _(type) \ + _(next) \ + _(lostEventCount) \ + +#define XR_LIST_STRUCT_XrEventDataInstanceLossPending(_) \ + _(type) \ + _(next) \ + _(lossTime) \ + +#define XR_LIST_STRUCT_XrEventDataSessionStateChanged(_) \ + _(type) \ + _(next) \ + _(session) \ + _(state) \ + _(time) \ + +#define XR_LIST_STRUCT_XrEventDataReferenceSpaceChangePending(_) \ + _(type) \ + _(next) \ + _(session) \ + _(referenceSpaceType) \ + _(changeTime) \ + _(poseValid) \ + _(poseInPreviousSpace) \ + +#define XR_LIST_STRUCT_XrEventDataInteractionProfileChanged(_) \ + _(type) \ + _(next) \ + _(session) \ + +#define XR_LIST_STRUCT_XrHapticVibration(_) \ + _(type) \ + _(next) \ + _(duration) \ + _(frequency) \ + _(amplitude) \ + +#define XR_LIST_STRUCT_XrOffset2Df(_) \ + _(x) \ + _(y) \ + +#define XR_LIST_STRUCT_XrRect2Df(_) \ + _(offset) \ + _(extent) \ + +#define XR_LIST_STRUCT_XrVector4f(_) \ + _(x) \ + _(y) \ + _(z) \ + _(w) \ + +#define XR_LIST_STRUCT_XrColor4f(_) \ + _(r) \ + _(g) \ + _(b) \ + _(a) \ + +#define XR_LIST_STRUCT_XrCompositionLayerCubeKHR(_) \ + _(type) \ + _(next) \ + _(layerFlags) \ + _(space) \ + _(eyeVisibility) \ + _(swapchain) \ + _(imageArrayIndex) \ + _(orientation) \ + +#define XR_LIST_STRUCT_XrInstanceCreateInfoAndroidKHR(_) \ + _(type) \ + _(next) \ + _(applicationVM) \ + _(applicationActivity) \ + +#define XR_LIST_STRUCT_XrCompositionLayerDepthInfoKHR(_) \ + _(type) \ + _(next) \ + _(subImage) \ + _(minDepth) \ + _(maxDepth) \ + _(nearZ) \ + _(farZ) \ + +#define XR_LIST_STRUCT_XrVulkanSwapchainFormatListCreateInfoKHR(_) \ + _(type) \ + _(next) \ + _(viewFormatCount) \ + _(viewFormats) \ + +#define XR_LIST_STRUCT_XrCompositionLayerCylinderKHR(_) \ + _(type) \ + _(next) \ + _(layerFlags) \ + _(space) \ + _(eyeVisibility) \ + _(subImage) \ + _(pose) \ + _(radius) \ + _(centralAngle) \ + _(aspectRatio) \ + +#define XR_LIST_STRUCT_XrCompositionLayerEquirectKHR(_) \ + _(type) \ + _(next) \ + _(layerFlags) \ + _(space) \ + _(eyeVisibility) \ + _(subImage) \ + _(pose) \ + _(radius) \ + _(scale) \ + _(bias) \ + +#define XR_LIST_STRUCT_XrGraphicsBindingOpenGLWin32KHR(_) \ + _(type) \ + _(next) \ + _(hDC) \ + _(hGLRC) \ + +#define XR_LIST_STRUCT_XrGraphicsBindingOpenGLXlibKHR(_) \ + _(type) \ + _(next) \ + _(xDisplay) \ + _(visualid) \ + _(glxFBConfig) \ + _(glxDrawable) \ + _(glxContext) \ + +#define XR_LIST_STRUCT_XrGraphicsBindingOpenGLXcbKHR(_) \ + _(type) \ + _(next) \ + _(connection) \ + _(screenNumber) \ + _(fbconfigid) \ + _(visualid) \ + _(glxDrawable) \ + _(glxContext) \ + +#define XR_LIST_STRUCT_XrGraphicsBindingOpenGLWaylandKHR(_) \ + _(type) \ + _(next) \ + _(display) \ + +#define XR_LIST_STRUCT_XrSwapchainImageOpenGLKHR(_) \ + _(type) \ + _(next) \ + _(image) \ + +#define XR_LIST_STRUCT_XrGraphicsRequirementsOpenGLKHR(_) \ + _(type) \ + _(next) \ + _(minApiVersionSupported) \ + _(maxApiVersionSupported) \ + +#define XR_LIST_STRUCT_XrGraphicsBindingOpenGLESAndroidKHR(_) \ + _(type) \ + _(next) \ + _(display) \ + _(config) \ + _(context) \ + +#define XR_LIST_STRUCT_XrSwapchainImageOpenGLESKHR(_) \ + _(type) \ + _(next) \ + _(image) \ + +#define XR_LIST_STRUCT_XrGraphicsRequirementsOpenGLESKHR(_) \ + _(type) \ + _(next) \ + _(minApiVersionSupported) \ + _(maxApiVersionSupported) \ + +#define XR_LIST_STRUCT_XrGraphicsBindingVulkanKHR(_) \ + _(type) \ + _(next) \ + _(instance) \ + _(physicalDevice) \ + _(device) \ + _(queueFamilyIndex) \ + _(queueIndex) \ + +#define XR_LIST_STRUCT_XrSwapchainImageVulkanKHR(_) \ + _(type) \ + _(next) \ + _(image) \ + +#define XR_LIST_STRUCT_XrGraphicsRequirementsVulkanKHR(_) \ + _(type) \ + _(next) \ + _(minApiVersionSupported) \ + _(maxApiVersionSupported) \ + +#define XR_LIST_STRUCT_XrGraphicsBindingD3D11KHR(_) \ + _(type) \ + _(next) \ + _(device) \ + +#define XR_LIST_STRUCT_XrSwapchainImageD3D11KHR(_) \ + _(type) \ + _(next) \ + _(texture) \ + +#define XR_LIST_STRUCT_XrGraphicsRequirementsD3D11KHR(_) \ + _(type) \ + _(next) \ + _(adapterLuid) \ + _(minFeatureLevel) \ + +#define XR_LIST_STRUCT_XrGraphicsBindingD3D12KHR(_) \ + _(type) \ + _(next) \ + _(device) \ + _(queue) \ + +#define XR_LIST_STRUCT_XrSwapchainImageD3D12KHR(_) \ + _(type) \ + _(next) \ + _(texture) \ + +#define XR_LIST_STRUCT_XrGraphicsRequirementsD3D12KHR(_) \ + _(type) \ + _(next) \ + _(adapterLuid) \ + _(minFeatureLevel) \ + +#define XR_LIST_STRUCT_XrVisibilityMaskKHR(_) \ + _(type) \ + _(next) \ + _(vertexCapacityInput) \ + _(vertexCountOutput) \ + _(vertices) \ + _(indexCapacityInput) \ + _(indexCountOutput) \ + _(indices) \ + +#define XR_LIST_STRUCT_XrEventDataVisibilityMaskChangedKHR(_) \ + _(type) \ + _(next) \ + _(session) \ + _(viewConfigurationType) \ + _(viewIndex) \ + +#define XR_LIST_STRUCT_XrCompositionLayerColorScaleBiasKHR(_) \ + _(type) \ + _(next) \ + _(colorScale) \ + _(colorBias) \ + +#define XR_LIST_STRUCT_XrLoaderInitInfoBaseHeaderKHR(_) \ + _(type) \ + _(next) \ + +#define XR_LIST_STRUCT_XrLoaderInitInfoAndroidKHR(_) \ + _(type) \ + _(next) \ + _(applicationVM) \ + _(applicationContext) \ + +#define XR_LIST_STRUCT_XrVulkanInstanceCreateInfoKHR(_) \ + _(type) \ + _(next) \ + _(systemId) \ + _(createFlags) \ + _(pfnGetInstanceProcAddr) \ + _(vulkanCreateInfo) \ + _(vulkanAllocator) \ + +#define XR_LIST_STRUCT_XrVulkanDeviceCreateInfoKHR(_) \ + _(type) \ + _(next) \ + _(systemId) \ + _(createFlags) \ + _(pfnGetInstanceProcAddr) \ + _(vulkanPhysicalDevice) \ + _(vulkanCreateInfo) \ + _(vulkanAllocator) \ + +#define XR_LIST_STRUCT_XrVulkanGraphicsDeviceGetInfoKHR(_) \ + _(type) \ + _(next) \ + _(systemId) \ + _(vulkanInstance) \ + +#define XR_LIST_STRUCT_XrCompositionLayerEquirect2KHR(_) \ + _(type) \ + _(next) \ + _(layerFlags) \ + _(space) \ + _(eyeVisibility) \ + _(subImage) \ + _(pose) \ + _(radius) \ + _(centralHorizontalAngle) \ + _(upperVerticalAngle) \ + _(lowerVerticalAngle) \ + +#define XR_LIST_STRUCT_XrBindingModificationBaseHeaderKHR(_) \ + _(type) \ + _(next) \ + +#define XR_LIST_STRUCT_XrBindingModificationsKHR(_) \ + _(type) \ + _(next) \ + _(bindingModificationCount) \ + _(bindingModifications) \ + +#define XR_LIST_STRUCT_XrEventDataPerfSettingsEXT(_) \ + _(type) \ + _(next) \ + _(domain) \ + _(subDomain) \ + _(fromLevel) \ + _(toLevel) \ + +#define XR_LIST_STRUCT_XrDebugUtilsObjectNameInfoEXT(_) \ + _(type) \ + _(next) \ + _(objectType) \ + _(objectHandle) \ + _(objectName) \ + +#define XR_LIST_STRUCT_XrDebugUtilsLabelEXT(_) \ + _(type) \ + _(next) \ + _(labelName) \ + +#define XR_LIST_STRUCT_XrDebugUtilsMessengerCallbackDataEXT(_) \ + _(type) \ + _(next) \ + _(messageId) \ + _(functionName) \ + _(message) \ + _(objectCount) \ + _(objects) \ + _(sessionLabelCount) \ + _(sessionLabels) \ + +#define XR_LIST_STRUCT_XrDebugUtilsMessengerCreateInfoEXT(_) \ + _(type) \ + _(next) \ + _(messageSeverities) \ + _(messageTypes) \ + _(userCallback) \ + _(userData) \ + +#define XR_LIST_STRUCT_XrSystemEyeGazeInteractionPropertiesEXT(_) \ + _(type) \ + _(next) \ + _(supportsEyeGazeInteraction) \ + +#define XR_LIST_STRUCT_XrEyeGazeSampleTimeEXT(_) \ + _(type) \ + _(next) \ + _(time) \ + +#define XR_LIST_STRUCT_XrSessionCreateInfoOverlayEXTX(_) \ + _(type) \ + _(next) \ + _(createFlags) \ + _(sessionLayersPlacement) \ + +#define XR_LIST_STRUCT_XrEventDataMainSessionVisibilityChangedEXTX(_) \ + _(type) \ + _(next) \ + _(visible) \ + _(flags) \ + +#define XR_LIST_STRUCT_XrSpatialAnchorCreateInfoMSFT(_) \ + _(type) \ + _(next) \ + _(space) \ + _(pose) \ + _(time) \ + +#define XR_LIST_STRUCT_XrSpatialAnchorSpaceCreateInfoMSFT(_) \ + _(type) \ + _(next) \ + _(anchor) \ + _(poseInAnchorSpace) \ + +#define XR_LIST_STRUCT_XrCompositionLayerImageLayoutFB(_) \ + _(type) \ + _(next) \ + _(flags) \ + +#define XR_LIST_STRUCT_XrCompositionLayerAlphaBlendFB(_) \ + _(type) \ + _(next) \ + _(srcFactorColor) \ + _(dstFactorColor) \ + _(srcFactorAlpha) \ + _(dstFactorAlpha) \ + +#define XR_LIST_STRUCT_XrViewConfigurationDepthRangeEXT(_) \ + _(type) \ + _(next) \ + _(recommendedNearZ) \ + _(minNearZ) \ + _(recommendedFarZ) \ + _(maxFarZ) \ + +#define XR_LIST_STRUCT_XrGraphicsBindingEGLMNDX(_) \ + _(type) \ + _(next) \ + _(getProcAddress) \ + _(display) \ + _(config) \ + _(context) \ + +#define XR_LIST_STRUCT_XrSpatialGraphNodeSpaceCreateInfoMSFT(_) \ + _(type) \ + _(next) \ + _(nodeType) \ + _(nodeId) \ + _(pose) \ + +#define XR_LIST_STRUCT_XrSystemHandTrackingPropertiesEXT(_) \ + _(type) \ + _(next) \ + _(supportsHandTracking) \ + +#define XR_LIST_STRUCT_XrHandTrackerCreateInfoEXT(_) \ + _(type) \ + _(next) \ + _(hand) \ + _(handJointSet) \ + +#define XR_LIST_STRUCT_XrHandJointsLocateInfoEXT(_) \ + _(type) \ + _(next) \ + _(baseSpace) \ + _(time) \ + +#define XR_LIST_STRUCT_XrHandJointLocationEXT(_) \ + _(locationFlags) \ + _(pose) \ + _(radius) \ + +#define XR_LIST_STRUCT_XrHandJointVelocityEXT(_) \ + _(velocityFlags) \ + _(linearVelocity) \ + _(angularVelocity) \ + +#define XR_LIST_STRUCT_XrHandJointLocationsEXT(_) \ + _(type) \ + _(next) \ + _(isActive) \ + _(jointCount) \ + _(jointLocations) \ + +#define XR_LIST_STRUCT_XrHandJointVelocitiesEXT(_) \ + _(type) \ + _(next) \ + _(jointCount) \ + _(jointVelocities) \ + +#define XR_LIST_STRUCT_XrSystemHandTrackingMeshPropertiesMSFT(_) \ + _(type) \ + _(next) \ + _(supportsHandTrackingMesh) \ + _(maxHandMeshIndexCount) \ + _(maxHandMeshVertexCount) \ + +#define XR_LIST_STRUCT_XrHandMeshSpaceCreateInfoMSFT(_) \ + _(type) \ + _(next) \ + _(handPoseType) \ + _(poseInHandMeshSpace) \ + +#define XR_LIST_STRUCT_XrHandMeshUpdateInfoMSFT(_) \ + _(type) \ + _(next) \ + _(time) \ + _(handPoseType) \ + +#define XR_LIST_STRUCT_XrHandMeshIndexBufferMSFT(_) \ + _(indexBufferKey) \ + _(indexCapacityInput) \ + _(indexCountOutput) \ + _(indices) \ + +#define XR_LIST_STRUCT_XrHandMeshVertexMSFT(_) \ + _(position) \ + _(normal) \ + +#define XR_LIST_STRUCT_XrHandMeshVertexBufferMSFT(_) \ + _(vertexUpdateTime) \ + _(vertexCapacityInput) \ + _(vertexCountOutput) \ + _(vertices) \ + +#define XR_LIST_STRUCT_XrHandMeshMSFT(_) \ + _(type) \ + _(next) \ + _(isActive) \ + _(indexBufferChanged) \ + _(vertexBufferChanged) \ + _(indexBuffer) \ + _(vertexBuffer) \ + +#define XR_LIST_STRUCT_XrHandPoseTypeInfoMSFT(_) \ + _(type) \ + _(next) \ + _(handPoseType) \ + +#define XR_LIST_STRUCT_XrSecondaryViewConfigurationSessionBeginInfoMSFT(_) \ + _(type) \ + _(next) \ + _(viewConfigurationCount) \ + _(enabledViewConfigurationTypes) \ + +#define XR_LIST_STRUCT_XrSecondaryViewConfigurationStateMSFT(_) \ + _(type) \ + _(next) \ + _(viewConfigurationType) \ + _(active) \ + +#define XR_LIST_STRUCT_XrSecondaryViewConfigurationFrameStateMSFT(_) \ + _(type) \ + _(next) \ + _(viewConfigurationCount) \ + _(viewConfigurationStates) \ + +#define XR_LIST_STRUCT_XrSecondaryViewConfigurationLayerInfoMSFT(_) \ + _(type) \ + _(next) \ + _(viewConfigurationType) \ + _(environmentBlendMode) \ + _(layerCount) \ + _(layers) \ + +#define XR_LIST_STRUCT_XrSecondaryViewConfigurationFrameEndInfoMSFT(_) \ + _(type) \ + _(next) \ + _(viewConfigurationCount) \ + _(viewConfigurationLayersInfo) \ + +#define XR_LIST_STRUCT_XrSecondaryViewConfigurationSwapchainCreateInfoMSFT(_) \ + _(type) \ + _(next) \ + _(viewConfigurationType) \ + +#define XR_LIST_STRUCT_XrControllerModelKeyStateMSFT(_) \ + _(type) \ + _(next) \ + _(modelKey) \ + +#define XR_LIST_STRUCT_XrControllerModelNodePropertiesMSFT(_) \ + _(type) \ + _(next) \ + _(parentNodeName) \ + _(nodeName) \ + +#define XR_LIST_STRUCT_XrControllerModelPropertiesMSFT(_) \ + _(type) \ + _(next) \ + _(nodeCapacityInput) \ + _(nodeCountOutput) \ + _(nodeProperties) \ + +#define XR_LIST_STRUCT_XrControllerModelNodeStateMSFT(_) \ + _(type) \ + _(next) \ + _(nodePose) \ + +#define XR_LIST_STRUCT_XrControllerModelStateMSFT(_) \ + _(type) \ + _(next) \ + _(nodeCapacityInput) \ + _(nodeCountOutput) \ + _(nodeStates) \ + +#define XR_LIST_STRUCT_XrViewConfigurationViewFovEPIC(_) \ + _(type) \ + _(next) \ + _(recommendedFov) \ + _(maxMutableFov) \ + +#define XR_LIST_STRUCT_XrHolographicWindowAttachmentMSFT(_) \ + _(type) \ + _(next) \ + _(holographicSpace) \ + _(coreWindow) \ + +#define XR_LIST_STRUCT_XrCompositionLayerReprojectionInfoMSFT(_) \ + _(type) \ + _(next) \ + _(reprojectionMode) \ + +#define XR_LIST_STRUCT_XrCompositionLayerReprojectionPlaneOverrideMSFT(_) \ + _(type) \ + _(next) \ + _(position) \ + _(normal) \ + _(velocity) \ + +#define XR_LIST_STRUCT_XrAndroidSurfaceSwapchainCreateInfoFB(_) \ + _(type) \ + _(next) \ + _(createFlags) \ + +#define XR_LIST_STRUCT_XrSwapchainStateBaseHeaderFB(_) \ + _(type) \ + _(next) \ + +#define XR_LIST_STRUCT_XrCompositionLayerSecureContentFB(_) \ + _(type) \ + _(next) \ + _(flags) \ + +#define XR_LIST_STRUCT_XrInteractionProfileAnalogThresholdVALVE(_) \ + _(type) \ + _(next) \ + _(action) \ + _(binding) \ + _(onThreshold) \ + _(offThreshold) \ + _(onHaptic) \ + _(offHaptic) \ + +#define XR_LIST_STRUCT_XrHandJointsMotionRangeInfoEXT(_) \ + _(type) \ + _(next) \ + _(handJointsMotionRange) \ + +#define XR_LIST_STRUCT_XrUuidMSFT(_) \ + _(bytes) \ + +#define XR_LIST_STRUCT_XrSceneObserverCreateInfoMSFT(_) \ + _(type) \ + _(next) \ + +#define XR_LIST_STRUCT_XrSceneCreateInfoMSFT(_) \ + _(type) \ + _(next) \ + +#define XR_LIST_STRUCT_XrSceneSphereBoundMSFT(_) \ + _(center) \ + _(radius) \ + +#define XR_LIST_STRUCT_XrSceneOrientedBoxBoundMSFT(_) \ + _(pose) \ + _(extents) \ + +#define XR_LIST_STRUCT_XrSceneFrustumBoundMSFT(_) \ + _(pose) \ + _(fov) \ + _(farDistance) \ + +#define XR_LIST_STRUCT_XrSceneBoundsMSFT(_) \ + _(space) \ + _(time) \ + _(sphereCount) \ + _(spheres) \ + _(boxCount) \ + _(boxes) \ + _(frustumCount) \ + _(frustums) \ + +#define XR_LIST_STRUCT_XrNewSceneComputeInfoMSFT(_) \ + _(type) \ + _(next) \ + _(requestedFeatureCount) \ + _(requestedFeatures) \ + _(consistency) \ + _(bounds) \ + +#define XR_LIST_STRUCT_XrVisualMeshComputeLodInfoMSFT(_) \ + _(type) \ + _(next) \ + _(lod) \ + +#define XR_LIST_STRUCT_XrSceneComponentMSFT(_) \ + _(componentType) \ + _(id) \ + _(parentId) \ + _(updateTime) \ + +#define XR_LIST_STRUCT_XrSceneComponentsMSFT(_) \ + _(type) \ + _(next) \ + _(componentCapacityInput) \ + _(componentCountOutput) \ + _(components) \ + +#define XR_LIST_STRUCT_XrSceneComponentsGetInfoMSFT(_) \ + _(type) \ + _(next) \ + _(componentType) \ + +#define XR_LIST_STRUCT_XrSceneComponentLocationMSFT(_) \ + _(flags) \ + _(pose) \ + +#define XR_LIST_STRUCT_XrSceneComponentLocationsMSFT(_) \ + _(type) \ + _(next) \ + _(locationCount) \ + _(locations) \ + +#define XR_LIST_STRUCT_XrSceneComponentsLocateInfoMSFT(_) \ + _(type) \ + _(next) \ + _(baseSpace) \ + _(time) \ + _(componentIdCount) \ + _(componentIds) \ + +#define XR_LIST_STRUCT_XrSceneObjectMSFT(_) \ + _(objectType) \ + +#define XR_LIST_STRUCT_XrSceneObjectsMSFT(_) \ + _(type) \ + _(next) \ + _(sceneObjectCount) \ + _(sceneObjects) \ + +#define XR_LIST_STRUCT_XrSceneComponentParentFilterInfoMSFT(_) \ + _(type) \ + _(next) \ + _(parentId) \ + +#define XR_LIST_STRUCT_XrSceneObjectTypesFilterInfoMSFT(_) \ + _(type) \ + _(next) \ + _(objectTypeCount) \ + _(objectTypes) \ + +#define XR_LIST_STRUCT_XrScenePlaneMSFT(_) \ + _(alignment) \ + _(size) \ + _(meshBufferId) \ + _(supportsIndicesUint16) \ + +#define XR_LIST_STRUCT_XrScenePlanesMSFT(_) \ + _(type) \ + _(next) \ + _(scenePlaneCount) \ + _(scenePlanes) \ + +#define XR_LIST_STRUCT_XrScenePlaneAlignmentFilterInfoMSFT(_) \ + _(type) \ + _(next) \ + _(alignmentCount) \ + _(alignments) \ + +#define XR_LIST_STRUCT_XrSceneMeshMSFT(_) \ + _(meshBufferId) \ + _(supportsIndicesUint16) \ + +#define XR_LIST_STRUCT_XrSceneMeshesMSFT(_) \ + _(type) \ + _(next) \ + _(sceneMeshCount) \ + _(sceneMeshes) \ + +#define XR_LIST_STRUCT_XrSceneMeshBuffersGetInfoMSFT(_) \ + _(type) \ + _(next) \ + _(meshBufferId) \ + +#define XR_LIST_STRUCT_XrSceneMeshBuffersMSFT(_) \ + _(type) \ + _(next) \ + +#define XR_LIST_STRUCT_XrSceneMeshVertexBufferMSFT(_) \ + _(type) \ + _(next) \ + _(vertexCapacityInput) \ + _(vertexCountOutput) \ + _(vertices) \ + +#define XR_LIST_STRUCT_XrSceneMeshIndicesUint32MSFT(_) \ + _(type) \ + _(next) \ + _(indexCapacityInput) \ + _(indexCountOutput) \ + _(indices) \ + +#define XR_LIST_STRUCT_XrSceneMeshIndicesUint16MSFT(_) \ + _(type) \ + _(next) \ + _(indexCapacityInput) \ + _(indexCountOutput) \ + _(indices) \ + +#define XR_LIST_STRUCT_XrSerializedSceneFragmentDataGetInfoMSFT(_) \ + _(type) \ + _(next) \ + _(sceneFragmentId) \ + +#define XR_LIST_STRUCT_XrDeserializeSceneFragmentMSFT(_) \ + _(bufferSize) \ + _(buffer) \ + +#define XR_LIST_STRUCT_XrSceneDeserializeInfoMSFT(_) \ + _(type) \ + _(next) \ + _(fragmentCount) \ + _(fragments) \ + +#define XR_LIST_STRUCT_XrEventDataDisplayRefreshRateChangedFB(_) \ + _(type) \ + _(next) \ + _(fromDisplayRefreshRate) \ + _(toDisplayRefreshRate) \ + +#define XR_LIST_STRUCT_XrViveTrackerPathsHTCX(_) \ + _(type) \ + _(next) \ + _(persistentPath) \ + _(rolePath) \ + +#define XR_LIST_STRUCT_XrEventDataViveTrackerConnectedHTCX(_) \ + _(type) \ + _(next) \ + _(paths) \ + +#define XR_LIST_STRUCT_XrSystemFacialTrackingPropertiesHTC(_) \ + _(type) \ + _(next) \ + _(supportEyeFacialTracking) \ + _(supportLipFacialTracking) \ + +#define XR_LIST_STRUCT_XrFacialExpressionsHTC(_) \ + _(type) \ + _(next) \ + _(isActive) \ + _(sampleTime) \ + _(expressionCount) \ + _(expressionWeightings) \ + +#define XR_LIST_STRUCT_XrFacialTrackerCreateInfoHTC(_) \ + _(type) \ + _(next) \ + _(facialTrackingType) \ + +#define XR_LIST_STRUCT_XrSystemColorSpacePropertiesFB(_) \ + _(type) \ + _(next) \ + _(colorSpace) \ + +#define XR_LIST_STRUCT_XrVector4sFB(_) \ + _(x) \ + _(y) \ + _(z) \ + _(w) \ + +#define XR_LIST_STRUCT_XrHandTrackingMeshFB(_) \ + _(type) \ + _(next) \ + _(jointCapacityInput) \ + _(jointCountOutput) \ + _(jointBindPoses) \ + _(jointRadii) \ + _(jointParents) \ + _(vertexCapacityInput) \ + _(vertexCountOutput) \ + _(vertexPositions) \ + _(vertexNormals) \ + _(vertexUVs) \ + _(vertexBlendIndices) \ + _(vertexBlendWeights) \ + _(indexCapacityInput) \ + _(indexCountOutput) \ + _(indices) \ + +#define XR_LIST_STRUCT_XrHandTrackingScaleFB(_) \ + _(type) \ + _(next) \ + _(sensorOutput) \ + _(currentOutput) \ + _(overrideHandScale) \ + _(overrideValueInput) \ + +#define XR_LIST_STRUCT_XrHandTrackingAimStateFB(_) \ + _(type) \ + _(next) \ + _(status) \ + _(aimPose) \ + _(pinchStrengthIndex) \ + _(pinchStrengthMiddle) \ + _(pinchStrengthRing) \ + _(pinchStrengthLittle) \ + +#define XR_LIST_STRUCT_XrHandCapsuleFB(_) \ + _(points) \ + _(radius) \ + _(joint) \ + +#define XR_LIST_STRUCT_XrHandTrackingCapsulesStateFB(_) \ + _(type) \ + _(next) \ + _(capsules) \ + +#define XR_LIST_STRUCT_XrFoveationProfileCreateInfoFB(_) \ + _(type) \ + _(next) \ + +#define XR_LIST_STRUCT_XrSwapchainCreateInfoFoveationFB(_) \ + _(type) \ + _(next) \ + _(flags) \ + +#define XR_LIST_STRUCT_XrSwapchainStateFoveationFB(_) \ + _(type) \ + _(next) \ + _(flags) \ + _(profile) \ + +#define XR_LIST_STRUCT_XrFoveationLevelProfileCreateInfoFB(_) \ + _(type) \ + _(next) \ + _(level) \ + _(verticalOffset) \ + _(dynamic) \ + +#define XR_LIST_STRUCT_XrSystemKeyboardTrackingPropertiesFB(_) \ + _(type) \ + _(next) \ + _(supportsKeyboardTracking) \ + +#define XR_LIST_STRUCT_XrKeyboardTrackingDescriptionFB(_) \ + _(trackedKeyboardId) \ + _(size) \ + _(flags) \ + _(name) \ + +#define XR_LIST_STRUCT_XrKeyboardSpaceCreateInfoFB(_) \ + _(type) \ + _(next) \ + _(trackedKeyboardId) \ + +#define XR_LIST_STRUCT_XrKeyboardTrackingQueryFB(_) \ + _(type) \ + _(next) \ + _(flags) \ + +#define XR_LIST_STRUCT_XrTriangleMeshCreateInfoFB(_) \ + _(type) \ + _(next) \ + _(flags) \ + _(windingOrder) \ + _(vertexCount) \ + _(vertexBuffer) \ + _(triangleCount) \ + _(indexBuffer) \ + +#define XR_LIST_STRUCT_XrSystemPassthroughPropertiesFB(_) \ + _(type) \ + _(next) \ + _(supportsPassthrough) \ + +#define XR_LIST_STRUCT_XrPassthroughCreateInfoFB(_) \ + _(type) \ + _(next) \ + _(flags) \ + +#define XR_LIST_STRUCT_XrPassthroughLayerCreateInfoFB(_) \ + _(type) \ + _(next) \ + _(passthrough) \ + _(flags) \ + _(purpose) \ + +#define XR_LIST_STRUCT_XrCompositionLayerPassthroughFB(_) \ + _(type) \ + _(next) \ + _(flags) \ + _(space) \ + _(layerHandle) \ + +#define XR_LIST_STRUCT_XrGeometryInstanceCreateInfoFB(_) \ + _(type) \ + _(next) \ + _(layer) \ + _(mesh) \ + _(baseSpace) \ + _(pose) \ + _(scale) \ + +#define XR_LIST_STRUCT_XrGeometryInstanceTransformFB(_) \ + _(type) \ + _(next) \ + _(baseSpace) \ + _(time) \ + _(pose) \ + _(scale) \ + +#define XR_LIST_STRUCT_XrPassthroughStyleFB(_) \ + _(type) \ + _(next) \ + _(textureOpacityFactor) \ + _(edgeColor) \ + +#define XR_LIST_STRUCT_XrPassthroughColorMapMonoToRgbaFB(_) \ + _(type) \ + _(next) \ + _(textureColorMap) \ + +#define XR_LIST_STRUCT_XrPassthroughColorMapMonoToMonoFB(_) \ + _(type) \ + _(next) \ + _(textureColorMap) \ + +#define XR_LIST_STRUCT_XrEventDataPassthroughStateChangedFB(_) \ + _(type) \ + _(next) \ + _(flags) \ + +#define XR_LIST_STRUCT_XrRenderModelPathInfoFB(_) \ + _(type) \ + _(next) \ + _(path) \ + +#define XR_LIST_STRUCT_XrRenderModelPropertiesFB(_) \ + _(type) \ + _(next) \ + _(vendorId) \ + _(modelName) \ + _(modelKey) \ + _(modelVersion) \ + _(flags) \ + +#define XR_LIST_STRUCT_XrRenderModelBufferFB(_) \ + _(type) \ + _(next) \ + _(bufferCapacityInput) \ + _(bufferCountOutput) \ + _(buffer) \ + +#define XR_LIST_STRUCT_XrRenderModelLoadInfoFB(_) \ + _(type) \ + _(next) \ + _(modelKey) \ + +#define XR_LIST_STRUCT_XrSystemRenderModelPropertiesFB(_) \ + _(type) \ + _(next) \ + _(supportsRenderModelLoading) \ + +#define XR_LIST_STRUCT_XrViewLocateFoveatedRenderingVARJO(_) \ + _(type) \ + _(next) \ + _(foveatedRenderingActive) \ + +#define XR_LIST_STRUCT_XrFoveatedViewConfigurationViewVARJO(_) \ + _(type) \ + _(next) \ + _(foveatedRenderingActive) \ + +#define XR_LIST_STRUCT_XrSystemFoveatedRenderingPropertiesVARJO(_) \ + _(type) \ + _(next) \ + _(supportsFoveatedRendering) \ + +#define XR_LIST_STRUCT_XrCompositionLayerDepthTestVARJO(_) \ + _(type) \ + _(next) \ + _(depthTestRangeNearZ) \ + _(depthTestRangeFarZ) \ + +#define XR_LIST_STRUCT_XrSystemMarkerTrackingPropertiesVARJO(_) \ + _(type) \ + _(next) \ + _(supportsMarkerTracking) \ + +#define XR_LIST_STRUCT_XrEventDataMarkerTrackingUpdateVARJO(_) \ + _(type) \ + _(next) \ + _(markerId) \ + _(isActive) \ + _(isPredicted) \ + _(time) \ + +#define XR_LIST_STRUCT_XrMarkerSpaceCreateInfoVARJO(_) \ + _(type) \ + _(next) \ + _(markerId) \ + _(poseInMarkerSpace) \ + +#define XR_LIST_STRUCT_XrSpatialAnchorPersistenceNameMSFT(_) \ + _(name) \ + +#define XR_LIST_STRUCT_XrSpatialAnchorPersistenceInfoMSFT(_) \ + _(type) \ + _(next) \ + _(spatialAnchorPersistenceName) \ + _(spatialAnchor) \ + +#define XR_LIST_STRUCT_XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT(_) \ + _(type) \ + _(next) \ + _(spatialAnchorStore) \ + _(spatialAnchorPersistenceName) \ + +#define XR_LIST_STRUCT_XrSwapchainImageFoveationVulkanFB(_) \ + _(type) \ + _(next) \ + _(image) \ + _(width) \ + _(height) \ + +#define XR_LIST_STRUCT_XrSwapchainStateAndroidSurfaceDimensionsFB(_) \ + _(type) \ + _(next) \ + _(width) \ + _(height) \ + +#define XR_LIST_STRUCT_XrSwapchainStateSamplerOpenGLESFB(_) \ + _(type) \ + _(next) \ + _(minFilter) \ + _(magFilter) \ + _(wrapModeS) \ + _(wrapModeT) \ + _(swizzleRed) \ + _(swizzleGreen) \ + _(swizzleBlue) \ + _(swizzleAlpha) \ + _(maxAnisotropy) \ + _(borderColor) \ + +#define XR_LIST_STRUCT_XrSwapchainStateSamplerVulkanFB(_) \ + _(type) \ + _(next) \ + _(minFilter) \ + _(magFilter) \ + _(mipmapMode) \ + _(wrapModeS) \ + _(wrapModeT) \ + _(swizzleRed) \ + _(swizzleGreen) \ + _(swizzleBlue) \ + _(swizzleAlpha) \ + _(maxAnisotropy) \ + _(borderColor) \ + +#define XR_LIST_STRUCT_XrCompositionLayerSpaceWarpInfoFB(_) \ + _(type) \ + _(next) \ + _(layerFlags) \ + _(motionVectorSubImage) \ + _(appSpaceDeltaPose) \ + _(depthSubImage) \ + _(minDepth) \ + _(maxDepth) \ + _(nearZ) \ + _(farZ) \ + +#define XR_LIST_STRUCT_XrSystemSpaceWarpPropertiesFB(_) \ + _(type) \ + _(next) \ + _(recommendedMotionVectorImageRectWidth) \ + _(recommendedMotionVectorImageRectHeight) \ + +#define XR_LIST_STRUCT_XrDigitalLensControlALMALENCE(_) \ + _(type) \ + _(next) \ + _(flags) \ + +#define XR_LIST_STRUCT_XrPassthroughKeyboardHandsIntensityFB(_) \ + _(type) \ + _(next) \ + _(leftHandIntensity) \ + _(rightHandIntensity) \ + +#define XR_LIST_STRUCT_XrUuidEXT(_) \ + _(data) \ + + + +#define XR_LIST_STRUCTURE_TYPES_CORE(_) \ + _(XrApiLayerProperties, XR_TYPE_API_LAYER_PROPERTIES) \ + _(XrExtensionProperties, XR_TYPE_EXTENSION_PROPERTIES) \ + _(XrInstanceCreateInfo, XR_TYPE_INSTANCE_CREATE_INFO) \ + _(XrInstanceProperties, XR_TYPE_INSTANCE_PROPERTIES) \ + _(XrEventDataBuffer, XR_TYPE_EVENT_DATA_BUFFER) \ + _(XrSystemGetInfo, XR_TYPE_SYSTEM_GET_INFO) \ + _(XrSystemProperties, XR_TYPE_SYSTEM_PROPERTIES) \ + _(XrSessionCreateInfo, XR_TYPE_SESSION_CREATE_INFO) \ + _(XrSpaceVelocity, XR_TYPE_SPACE_VELOCITY) \ + _(XrReferenceSpaceCreateInfo, XR_TYPE_REFERENCE_SPACE_CREATE_INFO) \ + _(XrActionSpaceCreateInfo, XR_TYPE_ACTION_SPACE_CREATE_INFO) \ + _(XrSpaceLocation, XR_TYPE_SPACE_LOCATION) \ + _(XrViewConfigurationProperties, XR_TYPE_VIEW_CONFIGURATION_PROPERTIES) \ + _(XrViewConfigurationView, XR_TYPE_VIEW_CONFIGURATION_VIEW) \ + _(XrSwapchainCreateInfo, XR_TYPE_SWAPCHAIN_CREATE_INFO) \ + _(XrSwapchainImageAcquireInfo, XR_TYPE_SWAPCHAIN_IMAGE_ACQUIRE_INFO) \ + _(XrSwapchainImageWaitInfo, XR_TYPE_SWAPCHAIN_IMAGE_WAIT_INFO) \ + _(XrSwapchainImageReleaseInfo, XR_TYPE_SWAPCHAIN_IMAGE_RELEASE_INFO) \ + _(XrSessionBeginInfo, XR_TYPE_SESSION_BEGIN_INFO) \ + _(XrFrameWaitInfo, XR_TYPE_FRAME_WAIT_INFO) \ + _(XrFrameState, XR_TYPE_FRAME_STATE) \ + _(XrFrameBeginInfo, XR_TYPE_FRAME_BEGIN_INFO) \ + _(XrFrameEndInfo, XR_TYPE_FRAME_END_INFO) \ + _(XrViewLocateInfo, XR_TYPE_VIEW_LOCATE_INFO) \ + _(XrViewState, XR_TYPE_VIEW_STATE) \ + _(XrView, XR_TYPE_VIEW) \ + _(XrActionSetCreateInfo, XR_TYPE_ACTION_SET_CREATE_INFO) \ + _(XrActionCreateInfo, XR_TYPE_ACTION_CREATE_INFO) \ + _(XrInteractionProfileSuggestedBinding, XR_TYPE_INTERACTION_PROFILE_SUGGESTED_BINDING) \ + _(XrSessionActionSetsAttachInfo, XR_TYPE_SESSION_ACTION_SETS_ATTACH_INFO) \ + _(XrInteractionProfileState, XR_TYPE_INTERACTION_PROFILE_STATE) \ + _(XrActionStateGetInfo, XR_TYPE_ACTION_STATE_GET_INFO) \ + _(XrActionStateBoolean, XR_TYPE_ACTION_STATE_BOOLEAN) \ + _(XrActionStateFloat, XR_TYPE_ACTION_STATE_FLOAT) \ + _(XrActionStateVector2f, XR_TYPE_ACTION_STATE_VECTOR2F) \ + _(XrActionStatePose, XR_TYPE_ACTION_STATE_POSE) \ + _(XrActionsSyncInfo, XR_TYPE_ACTIONS_SYNC_INFO) \ + _(XrBoundSourcesForActionEnumerateInfo, XR_TYPE_BOUND_SOURCES_FOR_ACTION_ENUMERATE_INFO) \ + _(XrInputSourceLocalizedNameGetInfo, XR_TYPE_INPUT_SOURCE_LOCALIZED_NAME_GET_INFO) \ + _(XrHapticActionInfo, XR_TYPE_HAPTIC_ACTION_INFO) \ + _(XrCompositionLayerProjectionView, XR_TYPE_COMPOSITION_LAYER_PROJECTION_VIEW) \ + _(XrCompositionLayerProjection, XR_TYPE_COMPOSITION_LAYER_PROJECTION) \ + _(XrCompositionLayerQuad, XR_TYPE_COMPOSITION_LAYER_QUAD) \ + _(XrEventDataEventsLost, XR_TYPE_EVENT_DATA_EVENTS_LOST) \ + _(XrEventDataInstanceLossPending, XR_TYPE_EVENT_DATA_INSTANCE_LOSS_PENDING) \ + _(XrEventDataSessionStateChanged, XR_TYPE_EVENT_DATA_SESSION_STATE_CHANGED) \ + _(XrEventDataReferenceSpaceChangePending, XR_TYPE_EVENT_DATA_REFERENCE_SPACE_CHANGE_PENDING) \ + _(XrEventDataInteractionProfileChanged, XR_TYPE_EVENT_DATA_INTERACTION_PROFILE_CHANGED) \ + _(XrHapticVibration, XR_TYPE_HAPTIC_VIBRATION) \ + _(XrCompositionLayerCubeKHR, XR_TYPE_COMPOSITION_LAYER_CUBE_KHR) \ + _(XrCompositionLayerDepthInfoKHR, XR_TYPE_COMPOSITION_LAYER_DEPTH_INFO_KHR) \ + _(XrCompositionLayerCylinderKHR, XR_TYPE_COMPOSITION_LAYER_CYLINDER_KHR) \ + _(XrCompositionLayerEquirectKHR, XR_TYPE_COMPOSITION_LAYER_EQUIRECT_KHR) \ + _(XrVisibilityMaskKHR, XR_TYPE_VISIBILITY_MASK_KHR) \ + _(XrEventDataVisibilityMaskChangedKHR, XR_TYPE_EVENT_DATA_VISIBILITY_MASK_CHANGED_KHR) \ + _(XrCompositionLayerColorScaleBiasKHR, XR_TYPE_COMPOSITION_LAYER_COLOR_SCALE_BIAS_KHR) \ + _(XrCompositionLayerEquirect2KHR, XR_TYPE_COMPOSITION_LAYER_EQUIRECT2_KHR) \ + _(XrBindingModificationsKHR, XR_TYPE_BINDING_MODIFICATIONS_KHR) \ + _(XrEventDataPerfSettingsEXT, XR_TYPE_EVENT_DATA_PERF_SETTINGS_EXT) \ + _(XrDebugUtilsObjectNameInfoEXT, XR_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT) \ + _(XrDebugUtilsLabelEXT, XR_TYPE_DEBUG_UTILS_LABEL_EXT) \ + _(XrDebugUtilsMessengerCallbackDataEXT, XR_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT) \ + _(XrDebugUtilsMessengerCreateInfoEXT, XR_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT) \ + _(XrSystemEyeGazeInteractionPropertiesEXT, XR_TYPE_SYSTEM_EYE_GAZE_INTERACTION_PROPERTIES_EXT) \ + _(XrEyeGazeSampleTimeEXT, XR_TYPE_EYE_GAZE_SAMPLE_TIME_EXT) \ + _(XrSessionCreateInfoOverlayEXTX, XR_TYPE_SESSION_CREATE_INFO_OVERLAY_EXTX) \ + _(XrEventDataMainSessionVisibilityChangedEXTX, XR_TYPE_EVENT_DATA_MAIN_SESSION_VISIBILITY_CHANGED_EXTX) \ + _(XrSpatialAnchorCreateInfoMSFT, XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_MSFT) \ + _(XrSpatialAnchorSpaceCreateInfoMSFT, XR_TYPE_SPATIAL_ANCHOR_SPACE_CREATE_INFO_MSFT) \ + _(XrCompositionLayerImageLayoutFB, XR_TYPE_COMPOSITION_LAYER_IMAGE_LAYOUT_FB) \ + _(XrCompositionLayerAlphaBlendFB, XR_TYPE_COMPOSITION_LAYER_ALPHA_BLEND_FB) \ + _(XrViewConfigurationDepthRangeEXT, XR_TYPE_VIEW_CONFIGURATION_DEPTH_RANGE_EXT) \ + _(XrSpatialGraphNodeSpaceCreateInfoMSFT, XR_TYPE_SPATIAL_GRAPH_NODE_SPACE_CREATE_INFO_MSFT) \ + _(XrSystemHandTrackingPropertiesEXT, XR_TYPE_SYSTEM_HAND_TRACKING_PROPERTIES_EXT) \ + _(XrHandTrackerCreateInfoEXT, XR_TYPE_HAND_TRACKER_CREATE_INFO_EXT) \ + _(XrHandJointsLocateInfoEXT, XR_TYPE_HAND_JOINTS_LOCATE_INFO_EXT) \ + _(XrHandJointLocationsEXT, XR_TYPE_HAND_JOINT_LOCATIONS_EXT) \ + _(XrHandJointVelocitiesEXT, XR_TYPE_HAND_JOINT_VELOCITIES_EXT) \ + _(XrSystemHandTrackingMeshPropertiesMSFT, XR_TYPE_SYSTEM_HAND_TRACKING_MESH_PROPERTIES_MSFT) \ + _(XrHandMeshSpaceCreateInfoMSFT, XR_TYPE_HAND_MESH_SPACE_CREATE_INFO_MSFT) \ + _(XrHandMeshUpdateInfoMSFT, XR_TYPE_HAND_MESH_UPDATE_INFO_MSFT) \ + _(XrHandMeshMSFT, XR_TYPE_HAND_MESH_MSFT) \ + _(XrHandPoseTypeInfoMSFT, XR_TYPE_HAND_POSE_TYPE_INFO_MSFT) \ + _(XrSecondaryViewConfigurationSessionBeginInfoMSFT, XR_TYPE_SECONDARY_VIEW_CONFIGURATION_SESSION_BEGIN_INFO_MSFT) \ + _(XrSecondaryViewConfigurationStateMSFT, XR_TYPE_SECONDARY_VIEW_CONFIGURATION_STATE_MSFT) \ + _(XrSecondaryViewConfigurationFrameStateMSFT, XR_TYPE_SECONDARY_VIEW_CONFIGURATION_FRAME_STATE_MSFT) \ + _(XrSecondaryViewConfigurationLayerInfoMSFT, XR_TYPE_SECONDARY_VIEW_CONFIGURATION_LAYER_INFO_MSFT) \ + _(XrSecondaryViewConfigurationFrameEndInfoMSFT, XR_TYPE_SECONDARY_VIEW_CONFIGURATION_FRAME_END_INFO_MSFT) \ + _(XrSecondaryViewConfigurationSwapchainCreateInfoMSFT, XR_TYPE_SECONDARY_VIEW_CONFIGURATION_SWAPCHAIN_CREATE_INFO_MSFT) \ + _(XrControllerModelKeyStateMSFT, XR_TYPE_CONTROLLER_MODEL_KEY_STATE_MSFT) \ + _(XrControllerModelNodePropertiesMSFT, XR_TYPE_CONTROLLER_MODEL_NODE_PROPERTIES_MSFT) \ + _(XrControllerModelPropertiesMSFT, XR_TYPE_CONTROLLER_MODEL_PROPERTIES_MSFT) \ + _(XrControllerModelNodeStateMSFT, XR_TYPE_CONTROLLER_MODEL_NODE_STATE_MSFT) \ + _(XrControllerModelStateMSFT, XR_TYPE_CONTROLLER_MODEL_STATE_MSFT) \ + _(XrViewConfigurationViewFovEPIC, XR_TYPE_VIEW_CONFIGURATION_VIEW_FOV_EPIC) \ + _(XrCompositionLayerReprojectionInfoMSFT, XR_TYPE_COMPOSITION_LAYER_REPROJECTION_INFO_MSFT) \ + _(XrCompositionLayerReprojectionPlaneOverrideMSFT, XR_TYPE_COMPOSITION_LAYER_REPROJECTION_PLANE_OVERRIDE_MSFT) \ + _(XrCompositionLayerSecureContentFB, XR_TYPE_COMPOSITION_LAYER_SECURE_CONTENT_FB) \ + _(XrInteractionProfileAnalogThresholdVALVE, XR_TYPE_INTERACTION_PROFILE_ANALOG_THRESHOLD_VALVE) \ + _(XrHandJointsMotionRangeInfoEXT, XR_TYPE_HAND_JOINTS_MOTION_RANGE_INFO_EXT) \ + _(XrSceneObserverCreateInfoMSFT, XR_TYPE_SCENE_OBSERVER_CREATE_INFO_MSFT) \ + _(XrSceneCreateInfoMSFT, XR_TYPE_SCENE_CREATE_INFO_MSFT) \ + _(XrNewSceneComputeInfoMSFT, XR_TYPE_NEW_SCENE_COMPUTE_INFO_MSFT) \ + _(XrVisualMeshComputeLodInfoMSFT, XR_TYPE_VISUAL_MESH_COMPUTE_LOD_INFO_MSFT) \ + _(XrSceneComponentsMSFT, XR_TYPE_SCENE_COMPONENTS_MSFT) \ + _(XrSceneComponentsGetInfoMSFT, XR_TYPE_SCENE_COMPONENTS_GET_INFO_MSFT) \ + _(XrSceneComponentLocationsMSFT, XR_TYPE_SCENE_COMPONENT_LOCATIONS_MSFT) \ + _(XrSceneComponentsLocateInfoMSFT, XR_TYPE_SCENE_COMPONENTS_LOCATE_INFO_MSFT) \ + _(XrSceneObjectsMSFT, XR_TYPE_SCENE_OBJECTS_MSFT) \ + _(XrSceneComponentParentFilterInfoMSFT, XR_TYPE_SCENE_COMPONENT_PARENT_FILTER_INFO_MSFT) \ + _(XrSceneObjectTypesFilterInfoMSFT, XR_TYPE_SCENE_OBJECT_TYPES_FILTER_INFO_MSFT) \ + _(XrScenePlanesMSFT, XR_TYPE_SCENE_PLANES_MSFT) \ + _(XrScenePlaneAlignmentFilterInfoMSFT, XR_TYPE_SCENE_PLANE_ALIGNMENT_FILTER_INFO_MSFT) \ + _(XrSceneMeshesMSFT, XR_TYPE_SCENE_MESHES_MSFT) \ + _(XrSceneMeshBuffersGetInfoMSFT, XR_TYPE_SCENE_MESH_BUFFERS_GET_INFO_MSFT) \ + _(XrSceneMeshBuffersMSFT, XR_TYPE_SCENE_MESH_BUFFERS_MSFT) \ + _(XrSceneMeshVertexBufferMSFT, XR_TYPE_SCENE_MESH_VERTEX_BUFFER_MSFT) \ + _(XrSceneMeshIndicesUint32MSFT, XR_TYPE_SCENE_MESH_INDICES_UINT32_MSFT) \ + _(XrSceneMeshIndicesUint16MSFT, XR_TYPE_SCENE_MESH_INDICES_UINT16_MSFT) \ + _(XrSerializedSceneFragmentDataGetInfoMSFT, XR_TYPE_SERIALIZED_SCENE_FRAGMENT_DATA_GET_INFO_MSFT) \ + _(XrSceneDeserializeInfoMSFT, XR_TYPE_SCENE_DESERIALIZE_INFO_MSFT) \ + _(XrEventDataDisplayRefreshRateChangedFB, XR_TYPE_EVENT_DATA_DISPLAY_REFRESH_RATE_CHANGED_FB) \ + _(XrViveTrackerPathsHTCX, XR_TYPE_VIVE_TRACKER_PATHS_HTCX) \ + _(XrEventDataViveTrackerConnectedHTCX, XR_TYPE_EVENT_DATA_VIVE_TRACKER_CONNECTED_HTCX) \ + _(XrSystemFacialTrackingPropertiesHTC, XR_TYPE_SYSTEM_FACIAL_TRACKING_PROPERTIES_HTC) \ + _(XrFacialExpressionsHTC, XR_TYPE_FACIAL_EXPRESSIONS_HTC) \ + _(XrFacialTrackerCreateInfoHTC, XR_TYPE_FACIAL_TRACKER_CREATE_INFO_HTC) \ + _(XrSystemColorSpacePropertiesFB, XR_TYPE_SYSTEM_COLOR_SPACE_PROPERTIES_FB) \ + _(XrHandTrackingMeshFB, XR_TYPE_HAND_TRACKING_MESH_FB) \ + _(XrHandTrackingScaleFB, XR_TYPE_HAND_TRACKING_SCALE_FB) \ + _(XrHandTrackingAimStateFB, XR_TYPE_HAND_TRACKING_AIM_STATE_FB) \ + _(XrHandTrackingCapsulesStateFB, XR_TYPE_HAND_TRACKING_CAPSULES_STATE_FB) \ + _(XrFoveationProfileCreateInfoFB, XR_TYPE_FOVEATION_PROFILE_CREATE_INFO_FB) \ + _(XrSwapchainCreateInfoFoveationFB, XR_TYPE_SWAPCHAIN_CREATE_INFO_FOVEATION_FB) \ + _(XrSwapchainStateFoveationFB, XR_TYPE_SWAPCHAIN_STATE_FOVEATION_FB) \ + _(XrFoveationLevelProfileCreateInfoFB, XR_TYPE_FOVEATION_LEVEL_PROFILE_CREATE_INFO_FB) \ + _(XrSystemKeyboardTrackingPropertiesFB, XR_TYPE_SYSTEM_KEYBOARD_TRACKING_PROPERTIES_FB) \ + _(XrKeyboardSpaceCreateInfoFB, XR_TYPE_KEYBOARD_SPACE_CREATE_INFO_FB) \ + _(XrKeyboardTrackingQueryFB, XR_TYPE_KEYBOARD_TRACKING_QUERY_FB) \ + _(XrTriangleMeshCreateInfoFB, XR_TYPE_TRIANGLE_MESH_CREATE_INFO_FB) \ + _(XrSystemPassthroughPropertiesFB, XR_TYPE_SYSTEM_PASSTHROUGH_PROPERTIES_FB) \ + _(XrPassthroughCreateInfoFB, XR_TYPE_PASSTHROUGH_CREATE_INFO_FB) \ + _(XrPassthroughLayerCreateInfoFB, XR_TYPE_PASSTHROUGH_LAYER_CREATE_INFO_FB) \ + _(XrCompositionLayerPassthroughFB, XR_TYPE_COMPOSITION_LAYER_PASSTHROUGH_FB) \ + _(XrGeometryInstanceCreateInfoFB, XR_TYPE_GEOMETRY_INSTANCE_CREATE_INFO_FB) \ + _(XrGeometryInstanceTransformFB, XR_TYPE_GEOMETRY_INSTANCE_TRANSFORM_FB) \ + _(XrPassthroughStyleFB, XR_TYPE_PASSTHROUGH_STYLE_FB) \ + _(XrPassthroughColorMapMonoToRgbaFB, XR_TYPE_PASSTHROUGH_COLOR_MAP_MONO_TO_RGBA_FB) \ + _(XrPassthroughColorMapMonoToMonoFB, XR_TYPE_PASSTHROUGH_COLOR_MAP_MONO_TO_MONO_FB) \ + _(XrEventDataPassthroughStateChangedFB, XR_TYPE_EVENT_DATA_PASSTHROUGH_STATE_CHANGED_FB) \ + _(XrRenderModelPathInfoFB, XR_TYPE_RENDER_MODEL_PATH_INFO_FB) \ + _(XrRenderModelPropertiesFB, XR_TYPE_RENDER_MODEL_PROPERTIES_FB) \ + _(XrRenderModelBufferFB, XR_TYPE_RENDER_MODEL_BUFFER_FB) \ + _(XrRenderModelLoadInfoFB, XR_TYPE_RENDER_MODEL_LOAD_INFO_FB) \ + _(XrSystemRenderModelPropertiesFB, XR_TYPE_SYSTEM_RENDER_MODEL_PROPERTIES_FB) \ + _(XrViewLocateFoveatedRenderingVARJO, XR_TYPE_VIEW_LOCATE_FOVEATED_RENDERING_VARJO) \ + _(XrFoveatedViewConfigurationViewVARJO, XR_TYPE_FOVEATED_VIEW_CONFIGURATION_VIEW_VARJO) \ + _(XrSystemFoveatedRenderingPropertiesVARJO, XR_TYPE_SYSTEM_FOVEATED_RENDERING_PROPERTIES_VARJO) \ + _(XrCompositionLayerDepthTestVARJO, XR_TYPE_COMPOSITION_LAYER_DEPTH_TEST_VARJO) \ + _(XrSystemMarkerTrackingPropertiesVARJO, XR_TYPE_SYSTEM_MARKER_TRACKING_PROPERTIES_VARJO) \ + _(XrEventDataMarkerTrackingUpdateVARJO, XR_TYPE_EVENT_DATA_MARKER_TRACKING_UPDATE_VARJO) \ + _(XrMarkerSpaceCreateInfoVARJO, XR_TYPE_MARKER_SPACE_CREATE_INFO_VARJO) \ + _(XrSpatialAnchorPersistenceInfoMSFT, XR_TYPE_SPATIAL_ANCHOR_PERSISTENCE_INFO_MSFT) \ + _(XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT, XR_TYPE_SPATIAL_ANCHOR_FROM_PERSISTED_ANCHOR_CREATE_INFO_MSFT) \ + _(XrCompositionLayerSpaceWarpInfoFB, XR_TYPE_COMPOSITION_LAYER_SPACE_WARP_INFO_FB) \ + _(XrSystemSpaceWarpPropertiesFB, XR_TYPE_SYSTEM_SPACE_WARP_PROPERTIES_FB) \ + _(XrDigitalLensControlALMALENCE, XR_TYPE_DIGITAL_LENS_CONTROL_ALMALENCE) \ + _(XrPassthroughKeyboardHandsIntensityFB, XR_TYPE_PASSTHROUGH_KEYBOARD_HANDS_INTENSITY_FB) \ + + + + +#if defined(XR_USE_GRAPHICS_API_D3D11) +#define XR_LIST_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_D3D11(_) \ + _(XrGraphicsBindingD3D11KHR, XR_TYPE_GRAPHICS_BINDING_D3D11_KHR) \ + _(XrSwapchainImageD3D11KHR, XR_TYPE_SWAPCHAIN_IMAGE_D3D11_KHR) \ + _(XrGraphicsRequirementsD3D11KHR, XR_TYPE_GRAPHICS_REQUIREMENTS_D3D11_KHR) \ + + +#else +#define XR_LIST_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_D3D11(_) +#endif + +#if defined(XR_USE_GRAPHICS_API_D3D12) +#define XR_LIST_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_D3D12(_) \ + _(XrGraphicsBindingD3D12KHR, XR_TYPE_GRAPHICS_BINDING_D3D12_KHR) \ + _(XrSwapchainImageD3D12KHR, XR_TYPE_SWAPCHAIN_IMAGE_D3D12_KHR) \ + _(XrGraphicsRequirementsD3D12KHR, XR_TYPE_GRAPHICS_REQUIREMENTS_D3D12_KHR) \ + + +#else +#define XR_LIST_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_D3D12(_) +#endif + +#if defined(XR_USE_GRAPHICS_API_OPENGL) +#define XR_LIST_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_OPENGL(_) \ + _(XrSwapchainImageOpenGLKHR, XR_TYPE_SWAPCHAIN_IMAGE_OPENGL_KHR) \ + _(XrGraphicsRequirementsOpenGLKHR, XR_TYPE_GRAPHICS_REQUIREMENTS_OPENGL_KHR) \ + + +#else +#define XR_LIST_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_OPENGL(_) +#endif + +#if defined(XR_USE_GRAPHICS_API_OPENGL) && defined(XR_USE_PLATFORM_WAYLAND) +#define XR_LIST_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_OPENGL_XR_USE_PLATFORM_WAYLAND(_) \ + _(XrGraphicsBindingOpenGLWaylandKHR, XR_TYPE_GRAPHICS_BINDING_OPENGL_WAYLAND_KHR) \ + + +#else +#define XR_LIST_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_OPENGL_XR_USE_PLATFORM_WAYLAND(_) +#endif + +#if defined(XR_USE_GRAPHICS_API_OPENGL) && defined(XR_USE_PLATFORM_WIN32) +#define XR_LIST_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_OPENGL_XR_USE_PLATFORM_WIN32(_) \ + _(XrGraphicsBindingOpenGLWin32KHR, XR_TYPE_GRAPHICS_BINDING_OPENGL_WIN32_KHR) \ + + +#else +#define XR_LIST_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_OPENGL_XR_USE_PLATFORM_WIN32(_) +#endif + +#if defined(XR_USE_GRAPHICS_API_OPENGL) && defined(XR_USE_PLATFORM_XCB) +#define XR_LIST_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_OPENGL_XR_USE_PLATFORM_XCB(_) \ + _(XrGraphicsBindingOpenGLXcbKHR, XR_TYPE_GRAPHICS_BINDING_OPENGL_XCB_KHR) \ + + +#else +#define XR_LIST_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_OPENGL_XR_USE_PLATFORM_XCB(_) +#endif + +#if defined(XR_USE_GRAPHICS_API_OPENGL) && defined(XR_USE_PLATFORM_XLIB) +#define XR_LIST_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_OPENGL_XR_USE_PLATFORM_XLIB(_) \ + _(XrGraphicsBindingOpenGLXlibKHR, XR_TYPE_GRAPHICS_BINDING_OPENGL_XLIB_KHR) \ + + +#else +#define XR_LIST_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_OPENGL_XR_USE_PLATFORM_XLIB(_) +#endif + +#if defined(XR_USE_GRAPHICS_API_OPENGL_ES) +#define XR_LIST_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_OPENGL_ES(_) \ + _(XrSwapchainImageOpenGLESKHR, XR_TYPE_SWAPCHAIN_IMAGE_OPENGL_ES_KHR) \ + _(XrGraphicsRequirementsOpenGLESKHR, XR_TYPE_GRAPHICS_REQUIREMENTS_OPENGL_ES_KHR) \ + _(XrSwapchainStateSamplerOpenGLESFB, XR_TYPE_SWAPCHAIN_STATE_SAMPLER_OPENGL_ES_FB) \ + + +#else +#define XR_LIST_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_OPENGL_ES(_) +#endif + +#if defined(XR_USE_GRAPHICS_API_OPENGL_ES) && defined(XR_USE_PLATFORM_ANDROID) +#define XR_LIST_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_OPENGL_ES_XR_USE_PLATFORM_ANDROID(_) \ + _(XrGraphicsBindingOpenGLESAndroidKHR, XR_TYPE_GRAPHICS_BINDING_OPENGL_ES_ANDROID_KHR) \ + + +#else +#define XR_LIST_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_OPENGL_ES_XR_USE_PLATFORM_ANDROID(_) +#endif + +#if defined(XR_USE_GRAPHICS_API_VULKAN) +#define XR_LIST_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_VULKAN(_) \ + _(XrVulkanSwapchainFormatListCreateInfoKHR, XR_TYPE_VULKAN_SWAPCHAIN_FORMAT_LIST_CREATE_INFO_KHR) \ + _(XrGraphicsBindingVulkanKHR, XR_TYPE_GRAPHICS_BINDING_VULKAN_KHR) \ + _(XrSwapchainImageVulkanKHR, XR_TYPE_SWAPCHAIN_IMAGE_VULKAN_KHR) \ + _(XrGraphicsRequirementsVulkanKHR, XR_TYPE_GRAPHICS_REQUIREMENTS_VULKAN_KHR) \ + _(XrVulkanInstanceCreateInfoKHR, XR_TYPE_VULKAN_INSTANCE_CREATE_INFO_KHR) \ + _(XrVulkanDeviceCreateInfoKHR, XR_TYPE_VULKAN_DEVICE_CREATE_INFO_KHR) \ + _(XrVulkanGraphicsDeviceGetInfoKHR, XR_TYPE_VULKAN_GRAPHICS_DEVICE_GET_INFO_KHR) \ + _(XrSwapchainImageFoveationVulkanFB, XR_TYPE_SWAPCHAIN_IMAGE_FOVEATION_VULKAN_FB) \ + _(XrSwapchainStateSamplerVulkanFB, XR_TYPE_SWAPCHAIN_STATE_SAMPLER_VULKAN_FB) \ + + +#else +#define XR_LIST_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_VULKAN(_) +#endif + +#if defined(XR_USE_PLATFORM_ANDROID) +#define XR_LIST_STRUCTURE_TYPES_XR_USE_PLATFORM_ANDROID(_) \ + _(XrInstanceCreateInfoAndroidKHR, XR_TYPE_INSTANCE_CREATE_INFO_ANDROID_KHR) \ + _(XrLoaderInitInfoAndroidKHR, XR_TYPE_LOADER_INIT_INFO_ANDROID_KHR) \ + _(XrAndroidSurfaceSwapchainCreateInfoFB, XR_TYPE_ANDROID_SURFACE_SWAPCHAIN_CREATE_INFO_FB) \ + _(XrSwapchainStateAndroidSurfaceDimensionsFB, XR_TYPE_SWAPCHAIN_STATE_ANDROID_SURFACE_DIMENSIONS_FB) \ + + +#else +#define XR_LIST_STRUCTURE_TYPES_XR_USE_PLATFORM_ANDROID(_) +#endif + +#if defined(XR_USE_PLATFORM_EGL) +#define XR_LIST_STRUCTURE_TYPES_XR_USE_PLATFORM_EGL(_) \ + _(XrGraphicsBindingEGLMNDX, XR_TYPE_GRAPHICS_BINDING_EGL_MNDX) \ + + +#else +#define XR_LIST_STRUCTURE_TYPES_XR_USE_PLATFORM_EGL(_) +#endif + +#if defined(XR_USE_PLATFORM_WIN32) +#define XR_LIST_STRUCTURE_TYPES_XR_USE_PLATFORM_WIN32(_) \ + _(XrHolographicWindowAttachmentMSFT, XR_TYPE_HOLOGRAPHIC_WINDOW_ATTACHMENT_MSFT) \ + + +#else +#define XR_LIST_STRUCTURE_TYPES_XR_USE_PLATFORM_WIN32(_) +#endif + +#define XR_LIST_STRUCTURE_TYPES(_) \ + XR_LIST_STRUCTURE_TYPES_CORE(_) \ + XR_LIST_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_D3D11(_) \ + XR_LIST_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_D3D12(_) \ + XR_LIST_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_OPENGL(_) \ + XR_LIST_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_OPENGL_XR_USE_PLATFORM_WAYLAND(_) \ + XR_LIST_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_OPENGL_XR_USE_PLATFORM_WIN32(_) \ + XR_LIST_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_OPENGL_XR_USE_PLATFORM_XCB(_) \ + XR_LIST_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_OPENGL_XR_USE_PLATFORM_XLIB(_) \ + XR_LIST_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_OPENGL_ES(_) \ + XR_LIST_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_OPENGL_ES_XR_USE_PLATFORM_ANDROID(_) \ + XR_LIST_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_VULKAN(_) \ + XR_LIST_STRUCTURE_TYPES_XR_USE_PLATFORM_ANDROID(_) \ + XR_LIST_STRUCTURE_TYPES_XR_USE_PLATFORM_EGL(_) \ + XR_LIST_STRUCTURE_TYPES_XR_USE_PLATFORM_WIN32(_) \ + + +#define XR_LIST_EXTENSIONS(_) \ + _(XR_KHR_android_thread_settings, 4) \ + _(XR_KHR_android_surface_swapchain, 5) \ + _(XR_KHR_composition_layer_cube, 7) \ + _(XR_KHR_android_create_instance, 9) \ + _(XR_KHR_composition_layer_depth, 11) \ + _(XR_KHR_vulkan_swapchain_format_list, 15) \ + _(XR_EXT_performance_settings, 16) \ + _(XR_EXT_thermal_query, 17) \ + _(XR_KHR_composition_layer_cylinder, 18) \ + _(XR_KHR_composition_layer_equirect, 19) \ + _(XR_EXT_debug_utils, 20) \ + _(XR_KHR_opengl_enable, 24) \ + _(XR_KHR_opengl_es_enable, 25) \ + _(XR_KHR_vulkan_enable, 26) \ + _(XR_KHR_D3D11_enable, 28) \ + _(XR_KHR_D3D12_enable, 29) \ + _(XR_EXT_eye_gaze_interaction, 31) \ + _(XR_KHR_visibility_mask, 32) \ + _(XR_EXTX_overlay, 34) \ + _(XR_KHR_composition_layer_color_scale_bias, 35) \ + _(XR_KHR_win32_convert_performance_counter_time, 36) \ + _(XR_KHR_convert_timespec_time, 37) \ + _(XR_VARJO_quad_views, 38) \ + _(XR_MSFT_unbounded_reference_space, 39) \ + _(XR_MSFT_spatial_anchor, 40) \ + _(XR_FB_composition_layer_image_layout, 41) \ + _(XR_FB_composition_layer_alpha_blend, 42) \ + _(XR_MND_headless, 43) \ + _(XR_OCULUS_android_session_state_enable, 45) \ + _(XR_EXT_view_configuration_depth_range, 47) \ + _(XR_EXT_conformance_automation, 48) \ + _(XR_MNDX_egl_enable, 49) \ + _(XR_MSFT_spatial_graph_bridge, 50) \ + _(XR_MSFT_hand_interaction, 51) \ + _(XR_EXT_hand_tracking, 52) \ + _(XR_MSFT_hand_tracking_mesh, 53) \ + _(XR_MSFT_secondary_view_configuration, 54) \ + _(XR_MSFT_first_person_observer, 55) \ + _(XR_MSFT_controller_model, 56) \ + _(XR_MSFT_perception_anchor_interop, 57) \ + _(XR_EXT_win32_appcontainer_compatible, 58) \ + _(XR_EPIC_view_configuration_fov, 60) \ + _(XR_MSFT_holographic_window_attachment, 64) \ + _(XR_MSFT_composition_layer_reprojection, 67) \ + _(XR_HUAWEI_controller_interaction, 70) \ + _(XR_FB_android_surface_swapchain_create, 71) \ + _(XR_FB_swapchain_update_state, 72) \ + _(XR_FB_composition_layer_secure_content, 73) \ + _(XR_VALVE_analog_threshold, 80) \ + _(XR_EXT_hand_joints_motion_range, 81) \ + _(XR_KHR_loader_init, 89) \ + _(XR_KHR_loader_init_android, 90) \ + _(XR_KHR_vulkan_enable2, 91) \ + _(XR_KHR_composition_layer_equirect2, 92) \ + _(XR_EXT_samsung_odyssey_controller, 95) \ + _(XR_EXT_hp_mixed_reality_controller, 96) \ + _(XR_MND_swapchain_usage_input_attachment_bit, 97) \ + _(XR_MSFT_scene_understanding, 98) \ + _(XR_MSFT_scene_understanding_serialization, 99) \ + _(XR_FB_display_refresh_rate, 102) \ + _(XR_HTC_vive_cosmos_controller_interaction, 103) \ + _(XR_HTCX_vive_tracker_interaction, 104) \ + _(XR_HTC_facial_tracking, 105) \ + _(XR_HTC_vive_focus3_controller_interaction, 106) \ + _(XR_FB_color_space, 109) \ + _(XR_FB_hand_tracking_mesh, 111) \ + _(XR_FB_hand_tracking_aim, 112) \ + _(XR_FB_hand_tracking_capsules, 113) \ + _(XR_FB_foveation, 115) \ + _(XR_FB_foveation_configuration, 116) \ + _(XR_FB_keyboard_tracking, 117) \ + _(XR_FB_triangle_mesh, 118) \ + _(XR_FB_passthrough, 119) \ + _(XR_FB_render_model, 120) \ + _(XR_KHR_binding_modification, 121) \ + _(XR_VARJO_foveated_rendering, 122) \ + _(XR_VARJO_composition_layer_depth_test, 123) \ + _(XR_VARJO_environment_depth_estimation, 124) \ + _(XR_VARJO_marker_tracking, 125) \ + _(XR_MSFT_spatial_anchor_persistence, 143) \ + _(XR_OCULUS_audio_device_guid, 160) \ + _(XR_FB_foveation_vulkan, 161) \ + _(XR_FB_swapchain_update_state_android_surface, 162) \ + _(XR_FB_swapchain_update_state_opengl_es, 163) \ + _(XR_FB_swapchain_update_state_vulkan, 164) \ + _(XR_KHR_swapchain_usage_input_attachment_bit, 166) \ + _(XR_FB_space_warp, 172) \ + _(XR_ALMALENCE_digital_lens_control, 197) \ + _(XR_FB_passthrough_keyboard_hands, 204) \ + _(XR_EXT_uuid, 300) \ + +#endif diff --git a/quest/.gitignore b/quest/.gitignore index 56dc5a93532f..508021bfe118 100644 --- a/quest/.gitignore +++ b/quest/.gitignore @@ -1,6 +1,5 @@ bin gen -libs obj build*/ gen diff --git a/quest/build.gradle b/quest/build.gradle index 36f51d66c683..7598518cfdb5 100644 --- a/quest/build.gradle +++ b/quest/build.gradle @@ -66,7 +66,7 @@ android { versionName ANDROID_VERSION_NAME } ndk { - abiFilters 'armeabi-v7a', 'arm64-v8a', 'x86', 'x86_64' + abiFilters 'arm64-v8a' } signingConfig signingConfigs.debug } @@ -99,9 +99,8 @@ android { java.srcDirs = ['../android/src'] aidl.srcDirs = ['../android/src'] resources.srcDirs = ['../android/src'] - assets.srcDirs = [ - '../assets', - ] + assets.srcDirs = ['../assets'] + jniLibs.srcDirs = ['libs'] } gold { res.srcDirs = ['../android/gold/res'] @@ -120,7 +119,7 @@ android { '-DANDROID_CPP_FEATURES=', '-DANDROID_STL=c++_static', '-DANDROID_ARM_NEON=TRUE', - '-DOPENXR=TRUE' + '-DOPENXR=TRUE' } } } diff --git a/quest/libs/arm64-v8a/libopenxr_loader.so b/quest/libs/arm64-v8a/libopenxr_loader.so new file mode 100755 index 0000000000000000000000000000000000000000..7b615830f29f3c6cdc712ff87b88cbc1645d7cf7 GIT binary patch literal 8250944 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%0Ak+9<+4oX1qX%ZQu3_U)`fL2k$4PI=syud# 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

?;=OijYlsv>h|zC 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'`66v2jFX#Lqdx}SEk8g` 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 z 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⪼= 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 hT8m^Z-&_MH$AmAr!_XEu5c83+!I~ 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%0AYkTN<e$v?B&s9Z@)wk4L8B844`wRo0 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

>zm`FMu&E=uVMx#2mO*~< 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

-~nbx9MLe0Go1|&`Fic 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%0DXQd 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⨌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τ=wkngKDsNHQH$<(rZmGxFEH99 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

h!Mjm#B`Kpm44WP_E+@b2x%rq$aAa%TIx= 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

dN7KQrAb&Ahzt^b9+^%sU>UfoQQ zz6Xh;M5cwx1HgI0QHAC?plI@48!9gVTS-#{#moQ=rtdY2F!?x3#DgG&sU*7a-+m^Tee=dpR zs0UsKAf{+olvnr9U@>9&_^9a)Ns5IjW{VcZ@?E6s!W(1kTcY14n@0vPUjh=UN+2J4DZ)ytt}TOm*qP-lGP>#Q0SWpJUWb{EA(Ojr0=!4-n+KGj7F*Ph2FZ-cG z(Ffi|?=V>#zGhR9Rg|yJVX_r)p0iZKZa@>s_fVMZ4Q!Q=B3QDKq~dTGhdWOANSOHr zq_+vDhRLNl;<(pSM7asnvmM0T4-!J7e|?yb+!(RiR=6a4;ntvVL)vB@jju)F>f>pY zG6v;Y7lza7P@uWA0#wp{_?*iKefVqFqeSCJW%>I;zhl*=w*QjA4& z6{giA0%$1t9t)EmU@Pww0k4;V|Cr{1<6*K~4w<_SSVcAf^)v-BJAf>spkIgi$Za5& z*^0E>UZg}6DJ$b&p-5R<#}z12Rw-6ek^H4t6^8%Jeup&Pqw!HXTiD7xXr=}4L7}u{nmC^IF09cyckK{I5u3C2DT-}$KZA0 zr^tq&W?PUr3K|veBX^K++R|~^(}_SjSzq7C9q#mgh=F zW&TYjPk2`zmWN5=3GZzkotLAEP{VoAO(Yx?ZvKuCd#Mr1gv+bIwmd%p>#j9UL7x8u z^r(PlI7l%HUnJZ|Zj^Y#mhpo2j2A-2>HMCvR~Qu}>ym~RAO)z3qr-jVMvK>M8uHpT z5Bi<5I z)&J0ZK2=N#G%0kxaVA_I0=DJvXA;R@LCxzRm*^a4Pq@4ToaZx|m|p;GB;T{)QcUp2 zr3i`{1^y|{G{sNhGJg)4`%SQlEDP$X1Y*_!nL%n&!=uQJ65@cZGzaaaIfT+Q!848t zh$9Y%J0nK<-v>An?!*^mX2ZWM9d7Ikk0KX#>JQ;;`X!;|L`pc)+k!AR>A>V%xZDYB z6`8VaJ3=@Mfg&jx^D0PN()n|^yqOiASIhsvX1;TwPDFVmh?yH?3Y|8b3XdWeXti8Ea-&2= zTbh;ZX;wy>*K#S=I$0%`(|g9xRLzCSqh|y@*r(*`1f`;0FOTxNa&e$kifgKJzNZI? zT0dtVUEzzk=mT#${_?c~*JUZ%BwVQ_w0eKjg+5IWgukgZn37uw*7_W9 z;R2vZpkuV6weZb3?X~f_aUIulg!x2!feW`j*4n~nq&5-PagESU;>xb!+MuaUWtes( zJ~uAAS~(Hl;SI`;UNVl1m3e8QmQAhDjz;kphSeI1)rD49W@D;y3bK%zz=*f?BfEF*u zErH(?T9$|_tZveEWXFIO{xb{64fF-0zn40d&l%N#-vUM|;?8HZ57K#zUdKg1PtH@^ zWGkUJeXf!!Du3{R4Ja~*bD>2&`jULjKOHt^vd5tcY=*IGc z(3#(;zXs=n#>Ytabz>&<6f~ST5i4XQBlW_@Y|tXc=g=8rY(P$m88Nr%X7VL9>1Oi% z$OCRBM{eIVP9ayNjFAWvYkY{lT*mMqRykt}a#G$nkB}9N2{-VGSz`{;s%#Vju3{Vq zu4;_`72mrxZbCzKqbN#L!+8CoQ>kg(g0z;AoQiKl?x%a3TcclDw>lTuiznb$$ZrZz z@;JJq`ATo}oN0tE?!X0W3kh{d#${Z5({txh{wvu=jmIsxd^uYJ?!?^9C}NCL*~2LK zG`_idgyQ~&)Gjd6kKxuvMn54hzcDI(1h+Oa3Ie*s=oO^0+QYjG6+iWt56^pIj&D9iXR-5`msEdKbvLYkCZjb=Pz`AnUH_u>(;DFIn?A z+}_EkJ94#f@;&HVk8&(xR1;^xHy4m!FQ7Y&+MupZe@T8*zCg+Os=A>IQF2BbaHx}V zf}}rT1gzm(toI;|0V$YfqrFFY#G{@(J6$x$f!FOBkS(b8*@>o z@pKpV8E8KJ1)*{n@n;xqSb$6Vwv%55)f(TnJ_|QLTDM}~L;s7PME6RULVF|~Cv^A+ z^kTl9x=;$f8_a0#F3e_(K0JjU!FN*MLwT*6sN13()`fxH;CGv^4qS-x-eEKVSI^yL zG-Cli^UUZl{O&V~M!3HiO^06wqxvYv14ds1{mtkeqz@Slhu(0}nxKPfzQn4DY zhO_R+?g?bwkKF=N>wfGcpf$_r#_CRJ!BvbZBDEEa{y_U$ccX^EFXLMZrz6G#Mw1}5 zE@nKBTs>sJv5;CP~_5BBQOzm>s_(%`MKOhw;7K{eSk~-+dU!y1#n~kabu0Q=s&V z6e9^SE;A|ybcInr^cU+|$&F~YO?<)RHq@GR|8xbUYu!5C59stHx`lZ!!RL!V^S#X4bhJx5`h-lQ;jf5Eh|jV7*_=*}6tXcB0VGah}p zQ5Rc;Q5p*tZv4dXRgLtKbn~M7ofEOkX5$W1%~%BkCu1+A zGdimwPUTF8zVd;)Acb*d0>wT8sv56AH6uS3Pu*Az+})_06^pG0`s1^%<}+T$sv(RG zJ1EkVLlkKOux?y|zwMet`VXxxju}Qg)&gN{0#yxdCx!nmDW% z%Zp@|6h)YD<5S>VMy0D{qI3gw83~{fMwN8BE%HCaavRrxBaI=Td5krn9^BQFqW(!lV%ubA!9MZ z6gGZ9_#(z?gehu#gfKD2?AJU;*Tdn15M`<$^CsPDDD^CCQ&%z>wqXrZZ62SFMYu zk*0Osw26AQuA4rC7}r@EiE!3+(@lV^>!xq6Mi1kqrZRG5T{j)y)suPs@_iud`sJ-a z*7eH+x_C0LUtR!YUB7$`$XeKbf6t>>muhzavM$x$3}juZ-3VG<@I~8i!q2)?`(MPh zF4Z0jKkHKMFocW0OrvT8YRI~|b~I|+nlulhwX6%JeP~JRLg`g#FKZzm^0j{^ul(UEJLdQtRUG9q_X*?%o4G>*DSY*7z^(jzhZE zg8vYuv@Y(xhnBG}?oPUarT-NzQ?DV0b@_H<^rxGXY3dz^bge7A8zP)_!S`*{pLN0a zT*R=hv{onkue82~I_WXTy0YD=+~A&*>w8EU{j~>DMm-Or))-yE zL~w`ET4=e;sP_+8s#lV}Mk!dT8SOy0o$JUi9e#;h2<6&`y4pi%6#OjXd;^eWoY#Of z=~t2-9tp$X7NPAQW07D(eAg(%_<@Yoxx>(R89g5Y{IJP@=`uC-*>e%27h4pl=_exE9Fi z8S)DOTEl1=qzMn*g+i(I4Be zh%x#Le(M-LM%^czr*I?DMspaweh6h_WFp*?OC&vT0I5AD^cm15M%~fAn;E?Uzb%ZG zA+BXyHUe7oAH}G%)o*6HQM)&1&@8nPwRVfqrJ-njM#nd!UgneZJj{l~RfMk8M$2p= zv>NCEqZ&YeGa3N&kkObpn1zhC0X=3kx+%uY9*P@00j2zj&{DLjWx$>r46~3;*>ynA z7*!hKRGu^Hh`Y$suTYHp&}SLCDbQybjYY6g*tv*CPrgr3BME_euey2aiyus)Z zN|}*Nev{$%fYJ5wXqi;iI{~JR9iAIYN^$w&Gt9>WbDM$0&A; zQyI@_J!)eDqwi7o6B!M{vCz#44-sR_nB2-OMgxIvGs*zE!>AO(-DOk{e)kyd#0WS& zo#HnC6m`JpdSB$~82PPcC}jts9z8Llt`nO6 zAx0FV;z)NhBYikV6r-U)TN$Mw+%`sEL$hV_rU8xnhqOFEILr9$Ph;yp@|%jB-e%-P zE8JnU9O>R=B$^@53&8q;O4vrZHMlAL}Kf0S&RC zWwagh)l5d-#!h7xqhauy&FCHYB`_L`H0Cf$gWo(xzc$Cw8KY;=oUw{hi$D$@FnWOz znsAW(CZZMQFgk?Zlzf%^T4CO}`HavZwBYIS{{X#%x;n$?6+D(jN(T6rOnz$8Oc*~#xP5t6ugzJu(HSHThSC3#E zG5YLnjGpb}mm9U4@I9eARB}cIQEN|lyHO9}(tjlBdnj+}&xC%0-!VoPP=Cpn$S(wO zH!;eE^6s4Y1b(&ApA%;gTDu(Eza@mGqTeTNAv6+sPS``}IZ8B#(LWeva~TbwmE!D6lPdx=H1;6B92wjAhO^li%_whH#?{7#GCqDzKg?j#q(Ju756^y)yk+FcJdy#J1 zmxOkqEt9?_v;gH@!zdMKEu&=UOFu}`deCC6$;~mMEbFToj;p5e@kk@In`M1nJ%(^> z^({Gp*_+XtxUSY z<+c|wEX%F#cE9CT5w?$Ixy3?@Ww{MNx|Zcu4{Nezk*!0ovn;Y>u&OM3Z5H(nw)AJh z&$1mWX03knu|il@pBt%JR^Jy$!?OAcL7!zIXP^}<3;922u`J};K$e9(1ubLQ!12kL zF?lz!9Qm_$6KhbXr>D~FQ{W`VAfwChvuyq`Xu+S@Z!M5z^AALMEekm>YTUAr+wJsQ z$gfa;mW6x-=~@=@B-Es3As0h9Yq#?mkhR-ciLzPtX<_7V-&UF#wqS>-7|pO3jx~y6 z2VKV4dN;?$l)faRYcZ-3gn2+Q2Ck(2W+}u{jWQ!>ul*5@3UuQP>*)(Ux=|N;3?n0_ z9{M7Tu9a7feXt-DV>*YAL3qVb5MCHVv%>R}9{N6vu8q{bT}4lNB4KO@t&z+J4ZH z+R8KZq^CGE57)lHQG??YR8-6zLamNq z(I5j}D+s^&*U0bIM*q{3&RDvqd`^BZ8)0IYMd+U%X#7RffjpzpHO3Q)Lby{)KLZ-t z8x8$*63|g-v2rjSnynlRLsbpc+^8x;yOZKlBDBYMax@Wrl0g?WgN*Y?MHt&bRii)B zv7Il_ry6w8ILO$Av=n0|!g!6%SnSIhC9&`|Hs<6EPhV!xMe87A)mRFD5h1-sIpnyp zu`Opv`e1@C(s2NDlR|btcM!(m+mwgK$S1aP=q9?cAFXB>zu%(gB#%GBVB{10-{xZy z;M41$$&b&N>n!jamR~Kyg3afWo3loX#4S4Ho&&_zvOJ%{tlJh;Y_< z-t$G6y!k{dI;)HEu@LxpZ-0ZT#@)p^>W%)KtcyRT(GB$`jFzCPaXn`Z z(4Urd5o{XwP?L($G^dpQ{i=)hrZEZn6{GSJ(sLqbD)c8eUDORWcCd6hsA_Zr#g=m} zL`EdAtu^T{Wx6;QZ0tb|31i$+3SSCTGk!rx-53IY%OoG0GbQ@xk}fU<8+E>;1guz1(ilo^c9;Pde2xFcck$gZG{#?yP+1* z(^aD-db(!(JO%-b*@LOiJ^~IhPCzORV;mi#wTDlz;e*s+bcTP3Q5vyAjiHc+8QUNY zHwHtR%kV(zH12`AjN*_+7$YFfZB&KSZB&7Oq!EU=d5mU|dW;2-Mj34(^%`Y!_9J?6 zQx{QTMh4E46=N*QD2&fRRpT(5>>^8Ur-f_eE$dhP3q%r9wj)aOrMYNB5_bz z`u9$7P=%S~IJzu5F<4# zWkZ(0zR)2^*+oElm0kn{5$Ot21QihxrHUxM7g3rDNKru%6%-W#rC313j+O6s?|ZvD z3H;Cba!%&fxpSw!nRzpBTQj(i?z|)>4V}qg_(BFF)-f3QE`tXyGZ^&`gVCiPqzGej z8H{VqV8RFn6DKg3G?T%@%NRVefx+b08BFB*Zo?@_aA%j&b7_8aMVC`-O z>kctk{{e%IpEKBWiNWUU47U8uU|RwX=O((hr!aUWgTao<3|`A+u(Jh&-Mtv>8A8BQ zz%}h@Hkzrs7BXnQlR=A57_|J0K`VV6MFjlbj+cZD_G0<#0O1bq2R1ik(6r zikB{s?V(V-bTc`UVH^1v!?toM!}gLIRq@iD<#wjK%7YBM%aaUy%1aFIm47qrBk3q| z@zVVy9Yii(dZ4VqaENTkaHwp{@P65c;RA9U!w2QF497_Nk;>ww$4fdST)gxId5qyi zd4=I4G6BbXikE&=W-y#4t22B|HefhQwqf|B?9FhFe1PFxIhEl&`7FcvawWqB@>Pb5 z<$Da5$}br%lh+t7mp2){EIl|)TDawfygav{U5avj6% zau35D@;!#H$uAl1lGhmSkvAE>E-hDq8yhQ+jX42x^~8J5sKWtgn}!qBbRarCWtX^&Qt zVTx9jp;v3n(5KN4lqQxP+MmI&(F}(35K?x;6HJX<&ftM<3`QMf@ZbdoqyJ*?Pzuh+ zC6*milfl>sgK_;BjGxC~!X^e2-(fK6DuaiMJx1{!$zU+KE`urU7(6N*#V6lA`nO;_s!OK|;R^&2R(}Ka;ZVc89Ww3q{fjbAyV=#CHgCRQ@+;^D4&`%f) z`-Z{r8w~DGe4OHqD9vDGRR#~#V=$^Ug9m#t7(IeO`36%MG<=dlqvshkeu+Vo?F^b8 zWKeLDL9_^rj4EbY<|^eGFz!VKD1?29IxJ@Wk5;p8S%*Q#Tkq?R$!h zJyV0hvn?6Szn8&t6Bs-{m%)M!3>F?>u;^0;i+^UYq{JMuva~XT7aB8I)}6tN4>4Fi zpTSG(8N9rg!HN$Vth~x#mGfz`vbr3DHT4;+?ZRN)I0ow z@ysPFTk{ya(v8860SsQ9$YA$V4E8Kzuy+T6?5dBTQ^13{ zu;VLR{$7RH6V_<>&3L5QH=$q57ok&TT+icb?=FY$)2Pb8gu(H2O3q125bf3{3jcix zLoh9grjzxOU0lI+ApZy}9m=>!J$0vBbo>{|kBOEAIVV!D%}N%RCm{VtqI@b6oG5lQ zeq0yQ-#1>uX|?gA7XE>blus#U`tOz9;#120NJq*UaJ*~~E3G43HBLt|G4lGCGOMNw zUNM(WsE(MW_fY6Nei)Osi|{DNF%}G&QjQY#RXbv_^BjwqU76XAS`M+}AkxowE=lB_m!{mNnd;snXbeKP z^}>05^rF0rmfWGrO(SMH&O(A(Y@Hlywg9ouNmI#ni;`uc3b|U@l3JbzqRI`(m}wwK z<(YAPe-16dBTQbd)&iQA|4O9V(MY|pY_|*+Ex91>Mz13vpS zO>F55{{7l&?yx<`QQz68ZDRNWupiK7!j@I(`jI}kP}vFWZ>6u%TuWt?ww_furhW`6 zZc_P9`uw*04Wx2K`ihNnh%xwvb>73O72mKZdx{#<7Z_m^T`0}zgOZ4}MNGZ;8bhz7iWM}e7R>zm4*cZ-`cVT*TM(@FAFq}DpFiAlJtn`g6Gy*hP;Cs8z|Hdf4HnYEs(pF`OY zzqrabGn?A=o)SD!$xDt3X}A==V!4_aa3}1i+LU&jp3zhjCo6+p&SpM9(w}>~gt+fV z6lZypj9|;rVvapV$>GTbWe`CW6R3 zobgTx;l;EuuND_OXVJ`1X3O6#QEeO5fa%*Od6d^H=zd*$BGxxDy?c^ZmW(9=&g(%Em0^bq%wWzz!{W1U9|( zc6f#0j|j0J?JfC8Yiqi4`EK}MZsxf}QS*CzyZxpn_1Vf?xOT10LRb8K6D@nN$MFGvnk19NRqA9rEHe4Nug7z&=e`K7uH@u z1*8R1ZSL~*oT54Dq#;Jdbye`29Yj^JNqQZ^f70_=e?+T_zPt%CaVL{CEYiE3csi9Z zP45D)Yo>Z$RQ@{2OL3DKX}yER|4Vdm;LFx}>b(5wJ2m#A-NBTF`0m2m<3QkIz0!obt2jNS9q z{W*!JjDcrVSt&}}_t?LdY@RBk7KJD9WOGgzSYdl4KkAFnk99GpeS!Bi-#1Z})wY*d z#mvzr3@9}13mn&c-#%x~?*i*oE54e~TkMT$OrQT=b50l7YWrD9b2|*uv@h_1<{J}L zdBs+;ZoCwCLWQP%ffJgqV2nBK3%sUU@y&^{cdIddyM~+7zQ7xWTp2Unoc0Cw7iM=f zr+tBgg^U~@W={J8M+&hc9n5K8;9VQFLaWMs)udgt?2N{7tPp!s4Rd}Mc&`w9FV+?` zNesNNvQyvqJc*ykfe)iij~hByUg}l1`4|s;qzXmqbCu1xV&G(9e&r)BanD}~B5xZa$A2F}|~ z*NYa2*{Ah9G)Y>b1P*AvE>XR&Y@&X&@mYHL(4&cJV87<;_ntZ73|zRyp07+)hB;#q z8@`PrlSNL4QX+6!ZTMzK+k_6ovY%9$*@mpFYR4ww#EEeD9pOQ>7$wd`}FX;;W zml#a-@3mWl4he;C%iqZsF3L%CS7q^H_q9gxvcgDJ!E7=E z!pS`K4~$l29NEmA;c%G>vu>-P=Hd*#c2CQdz~i^5Dp}e6Ek1ikT2I_oOZc)svlO1Z zMM25b1Lz}cX0|>4;PBD|!fSSv&S;ISFy|Hp#mq5uC)QeVi!R!Z)g32~)PAsEj=ozQZk(#RPnqKd||>)~$!~)A;RA*4p*IwbY7u0u{mf z2X3#g)W%@c2CKgHzg30r^l3}$;O(`P0?p`b<>;`g%Jss5*{Ujaw>T&pDin3(iz=3x(zn$T zz9Tg)g)*vw;>giaF41u)9LZD_6i4*G@nu|6$W|4KI?|%DWyXJ7E#Z5lhNVzVRZtvx zX0%K6qjUnQg5t<-IKm2ss!-ICD{zFh>fTmM_{!o(O<1A6s-QSBbc{=kBu5&l3W_6r z|G@{bNuiahP}Grm*_N5eZMB4NKOA8*cdH7DBX^B+iK&!MJ5@n(#Emw>3f)zOqK?!@ z8)2=Ux78B9K{=Mfy{dxZ$liX*qQ!hT($_(+c&x5WjtE~y3rjXumGPLufvI&yx=ah> z{gMps4rvGm(E3xz(bC)cz*uGY*l8=R@G2 zqX4d(Mlwf4xkntdls8wQ>93_GieA{?3!HVZo@qJL6|svE#JOcb@Sn;p1b zNcnJUyC@*`FRF64v_vt5O#H4Yrw{quCC1>bUEnX3o!KPSCT0-(U)9Egmy^VE*c=PU z1k*d(G!dBt7i(fIvF!=OurjzW%5^5xZW+y>J`W z@iNanuZfwY>rr)s3oNcr(M^9eU=uy?nmbU+bW>zjA7E}q1}Y@PT8K!m^p{h-LbL4} zR(6W?ne^qDb+STEQ3a8nfJr6GaxEDfrtTur8&q_+Ms(VeDO2XvZ8WcK?JQ9C1r(UKS}5}Cg9$vl&(F-8`SVEUEW z5kCXG6%D7xIQcIbc*dAF;9GQxS&`3Ussit~SGG6v>I9MIGdq0N6sTWNv8rN7%|B zp6Q54Esr)hQOB7K+DN6mddW?pQ`YE6fInzM`Akp3S&6_Xtuj9pv%Rx5F}f?p*4~@UR7_MVIp4zB`;cmyALnWYpy%kL5h1&YGc;8lKm1uzcyd3Fjl8j!Q`P9D%jeL|{SLpLfS1ULhSE)nfv{@sq$+j#UpsfK%4owmwXOu(>^y{)$rA_ zw&8O#3bE%{+wi$}6k?aKw&8QjOUk{KG2azoZo}tRD#X6e+J?`qQi#34+R@If#)Es* zNQSjjotq=qw~yNPav}SpgJtg5zO%>7jq2RIThx39nwh(!x%Cwpwsy{&+n~8k3$ZVy zn;Q|iEhW{A79FZ{zwv!m!rW-d9VO{imgx_xnYzAGXUrv9?s%RVSPG;oe4RE} zvT3R;mXO!fx`E%Eqs3J2v~Pe9N7y>YI)H1Riv3>v>fcPtnx6j^`_DE&bnG zR`#BM!rW`gU7;2jIc_OLtj(C*4XOflc1z*rzviY-?sipy98ojnw>Eup_uN)X_?kU# z?zQ9|R239QW>}jsxyMum#gUl6yf_P#mdc zZN}tYQ56(N-o^rnHhpq`R27Ok@((7`to6rjwS@1$baSsIS7=IGRvbAAM`$x9*QF{b zjtsXpeR7Md3Pl}RZf*MH>bKPrzIz@s_gZqxstSrDqpZ!C+={A#;z)|M>62ScRVeC6 z6Km5ax7Ka7gzw@^bFU@0zN(-&Qrg;#$!(@8D30udBeb298&MUCI&uw;uvUlLYGD=n z!37=jrr*BCA>QCqj%1pb4#%Mx_m(957&FHI-~xv^TYUu6?BHC7=U+_Jf{QR)xs%7K z{^!gS-odvVWxLX_Q;FF6EW8J%$8_*Hhwnv)dD=U8)X_*$nGY43^#$iUeD*&z@yEbY zBKVOb2l1oEA4y9x*(y~DK9(>g%zNRQ=3q{$Un`E-Txiw1HLy6)Cit?Q$ zBVWD8;gisp!<&tG=m(#5_(pz|$ZrsXR}|Bxp6|xdL~)vI{CbNG-yf$FMMb>L4E}y= zygqvq`N&`JhEh(J%|4s$;>bLtEfc87tujpGl1@tCg7%VtriDjPQ!-dxi`7(Y`4G(2 zV#|tPO--j;uAHNQCISf;brHyKkSYS7H%b-yJIL*ym|NF6D)p1Ve{4`v)H)S} z^R>3iWSZ^Mtd7q^KUx=Fm8&ruOGlJgtsPQk-YjVzt*^C9>fJH-x|^$=V$sy8)~hn} z#X~ke{9bFXq9OFA&>lo8$E4l{xTB$!^nb1XSJFaFT4YvBjV1jwCEewgq>sguj%%Qq zAGXt+6>B}GHK&fR_4<+#U-5Rawca2wWD2pZwO;oT%36>4q++f07HY}SwO$oWP-Mz5 zlH~yvI;l}Zr?nn!Lh$qzYrVN$tvCa1J>zkPaGWvFi>~!(BPP1mTY>4gwbm=*ptaWf zw^5O`9yuaX-`11kYdv>_<35MaKd2x?t+955)ml z%2{4}S@xN7mZYn6X=R5)ZwI7#-K0nJojPakfadj--@zR%NWKrmt0I&^oOT5A3Z%Is;MwyS1T~R~iB!PZ9jy(5yj-xRFzaJ$gCH*$WnqJ$BH9{l5YPn$ z-XQ4TJGMbU?aKQE;(Dosg`e6gwKHrGMDH_TgWxc@)&{|Y1L7M59FHxSk*RORHVF24 z=uQ+i2&nh)1_2r54T8zNkyPnBaBf}r)@+Gw5L^darW~P+_)@pVF5Y;dCsU3wdu7?! z2EhVmo7#G2Y=dC8qCLBOY=htwqD$}RY$P{3wn1<%&QAR;P1ztIyWWeWjwiwW(Tg{f zl|l>fq8kLHPE;_tV;cli>@32df;j9Z zHVE=wh;0y14WztI*7cnTqZMJe<4&5Zj@ z|C65p!nbeM4~3oh?VI{PfQ;Y1A=2A~csj+n<@OEB3;L4$i(%FPqTarV$xS2i+c$AR zgsqcf++Ee%H-(if6S3PjBvo$TuyUt3k8a<@cxGJR>fy25H@%^$C|HK*_6;}PCeDv+B|B+w{O@em9+Pj zepK8q4!6cS+`ehES-E`^b5;00!xoTr`=$b7%9PRMsL#G2cKgQBKUxadH5(bfee+;c zWt5i9DjZYq36<#W8?h;N`$njPr9 zZ>UnDMf?2t*zFsYeGn>zZr_*{u`(39eWPfn4hkx_Z({W>Qs)g;Zr>1J_`+Law{K1j zh*qVSjA3j*3*o08Zr{8X)mx@f^D*5u^?Vs0#%|vfwc(o;l`X$D-fL}Rw{PO{gs);d zi@ipPB7EDg#BSfH+F4gE_O?RWUuVW{-#mhhnte+6+TLNY_iEFa&E=RnuTOIP_6-*p z_mR|M^({W#zG40>Dz((hrct_HB>dzA383o!(c?7rT8^L_zreI~KcrQ$)s|iqyFuE4ObrW2qgy%IzC2 z18yCum+nT{;2k>OzKQWoFH@5{D7SA|NQ0B`eVte2_6?VR`kl?zM0)9e)}etzDUn_K7RX#ZDsyGD0cgXT<1Z|Y`W>G6XUmU6dRX2 zB*$*w#Moxm(vS6y-@b{-MEVj)*L*`7wB=WNL^lruCw{JKau~}v* z=$I%+Z{M&2Rg*PQHZW0U8E)UiW#$C?{hZ|3?VFfkk-qzz`0X32*&-Kj%w<`6*?sZb zH>|}CDm~}v`0X3BS?uf*zkQ=9Uj8F~`zFp7fuu8mGr;_KQ8n8pj= zjC*41+R0$Z6k=QJ+Up~gbuIHr#ah>vwa3=A675i?Oea|hn*Zpe7G2lQ0nW27tZUP| z$JVuZ@i>h+&a=>qu4`Wa9$nXFV+-9{*A{WmTG#&FtjM~S91*E4Qk8WrJ5O#FUDvje zG?l};Hd;Qhshqm5rH*E}5B&qoR#Z4t^U3*77rf(eXEHQhatPt0ZuWQ+Ud|gYVm&_{bTISVYUTj^<(Nb?l z2Rd5UGRv1ZA-1mlVi;wBz0-ZjVRT&^scAKPTGz61Dh-jk`aWe{%lsfEni}q+tZSJc zB7XX)KjQ1!n7Y;N7Br8qYvVGr+vQ_DOea6`u&#}nv*O)b5MS5EW#+o}KBO95*TyEw zSl5mRpP%qp*XARi(RFPVM>S0NX+=ttc3zRT?i*W?Qj74uj3(!$vJrl2W!8!`I>*O~ z^aXIO73sJ^@f9h@V+&?v>J_mSX`)ujT#-_{=M^a#1(J7X)-sbI*I zv()~5A4b`Ej+M;5!0f&iV=K}smMjcXv~Bw5!#Kp0z*evn^M1pIXo6wJknbSHwG zif@CgPytx2_wm^j+NUW$AW77|F8oKZ=&Imx3RkG6WB(5cA}hDlg+%efgRq->eyo!* zSMH}4=E)tH>lCzuo|fCg!ZPrhygW|9cxvXGugP(AE=U`F^fsYpJrSh4lJusrW_?$! zcK94g&BiImzDGIm+Xg-eQ=Qpuu^|G!sBxi`4@uYO>qim zTAm}z>8pJRUwYgHo>O;;+Rk33#6BWYJ@_KzKDJ@MV?Dn9>ZudN=UEaHgY>x?|Ci8t z%8ifW?Z|Vuifs$F{yBk*s@QfBd>=x{A?H?u4*EK`=M<5(drKbo(%_!0Cu|zqF`CcZJLCN=sC9jH_u7jv2RbJed73)_r z*lRFaZBdc^eXilUgAT)ye<|a&dJ+1cm%hC!LaXs?C|--&J5O26c}u-o#kYdp-plU08yP<$Y|!vWVpli)Z76VTv{=A$ z{;_=2Xnj8UMQs>9p|KR3pj6V+-Qe*gPAYycoBD?7b7yQX3!@XlMn(^WjX7#e6K`B_ z4zbuHoSS$qy&SE{R@~KIUf(H7Oy*jmK!lzHqu8%pK@^D4d}92@)k1-2QnL)c5mgue z^D0oy$0Z>R++uJ1P2MR6BykTF)m^s;X1|E#)GYl_=TDH`FPU2#p9nRplm`lW?lIYK&3?*?xyGa-vfFVp%v`yxO4f>g7YYG>ifR~I+@T)b`P3`L-YR)&L6~S zrx+GqY(2DjpNW~@n1>lS!P6K}%prZ+` zYm^h(OTaUC|%G#LjO-Xux?!V;@r zbR6##UUOuLb#6;kpF{(>)siXGrBH;pj~C`z5pprkdY2RyiBOZT5n*Y(hp;Vny~$pm zOFZ5kzr)^_%Y_4uZi-hYCW$^IZq2T9Kw^w$c){bH&o<+(HQDif5`IY|QTRH<^|=t5 z9EPQlWT|^xVp>{2mKGGX^eilWAA$amxISA7?T3Bu*dpAfXR=&k!9NKiWk|e&;~5F9 z=z>Hha3oH(>2m{0i6=2mr5xv!sWyfGU2HnOiwQ%?+WwP3_XE}2aI-9piG^Ou|2??V zd{F4^{|)G)gx<@#4*=C$S8L@e89AcvonI%4QoZTR!J!E+CW%r7{Jf`c2YV?Hp+3ZI#*F<~^$CMM>lm6x z+y>13gt>%7vWXr{)8}}Bg`O?S+UNEWTrU6e2&$YM6JlUmqnq@#AvQC9v}wK z3FGIa&4&Xgleu+ElGu*fNcvCa!EJt)*}GwGpvla&$nI~b#`HV+YfN4i`kz7a=P|=7 zlj)}!%vnOq`qzNF7}ZoJ!%yX~kkB%rx9>|5W!msWhXN7Wg|y1FR~VlVqqD-e@-P_P zV+^ku?@rW0nTs*52)#p=?^PHrNn@a!6r(OpI^ijDkzU!6+_c94qnv zNbl)5cg`fL25Lkh2PLu~E+Qr#h~&$X7*~XDQl?&vGctdCBS~CFYU#&qu{nhIGTS9O z^cq=sB^JReAEqRU4m~skqW9t=!bE5{Inpo26`{6dVWPrlL%BGiFg~RygA_(*iZWSY zv>?V%h0%r>BNRp_VmzoYI#Me8Q%<9F z^df98_mt2cigG=kV(14l{g1*}N3mazF?bd%LdS`_GtMkM~C~uJ)OJiISx}Wm1 zTw#1h8arYPbFc{w!{n>X`*AK|BJ?ViPX8De42nESVRR=iK2#VVQ>1`!G205{g#qCNfA%Q^+NwpiGHRqI#6-UQW%4XF+0vE z_>xRlDQddlM_gqqlUIaoR#3q}D!l4NWTIdXS*lr-9U4TLc{i4#Rmop%19v_TCL|J} zZz#bpV`?Hap5pz^EWzYv?#i++A_5*-Oq**?tw{ih|$BT4FqDTt%5KL`VFhQ%2pK zAb@`|=x;H_$*98%q~VyVmK+eu#125lP_DHlP!L9cgrN>y!M#7ut+f|Vn~YgrQsLqgRYRE>N7$# zD&yyAGH3B5nr+6#q4K0ZiWv&G)E%hU2bsaPxh_K?(jBX)RUpRHqLFim`(zPr)7^(s zMDmC5dk|Lyua_C)fD>qX5jxpVL1zpzuRezIFQSuAtJTnpRp8${F;BeCnbg+kmj*(2 zew8RPw!}r;lZh0e1r+PuxTrqIYJxDIqc+26nX#24us^kK;O0ZdW86$dEl)edzRx5= zK|FyohQ&;Y&|WO{GKR+)wKfuCinVyIiRnkix3Ly#aqAHGT4Anbe-d^LGG?$jssIuC z_$4ql#u%oBx<9Q2_gAtIIvjL~jMcFPs;FBD>$!|^6eCoen%vA-Wb~WA$$#F$WJ_k- z3T>lC{-~;#K}M!AhXN5wqn0r}rXoU5P@Jb?49il|ey7N4qr^)pT}))PQy4nxDXYE0 zco`#FR!4>5!k22ZIxCFb7)G+XDvY z;Yqw{sw#p_jwP9Rb-QRz+nX)Ckl+sA5`0F}^-p< zma!(-&#qLH3yu5`A$O)zRLW(4Ifxk)p&;o7S(mn>t)az55zIEg#!WLlw?Wrz2%JAM zBSKBdLTx3rTEsBxOfi{H+-C8bG)?}n58Ow2$;An6oDGu(IT^~L3_i|FmAELBix)hV zUf@}X!fk*VOQm@{D#y5HzYFOYuq!R*8DLRSU38yH%lHLPQPCALxSC(^6cxRV?bb>I z;)O|a5jsWOF@?F-v}7%ISS$4@EW#!QaYq;CM)yj`Lu3v&oVb~SpEAtNYP|!1tGej^HqK-?f})5X!2?eA=Y6Zv-147gwt>G65%(AMsSf2O^cD44^ZCrxVa_*yCGMVBbzpE!q9{$cP`C+& zhST_XPfW!c$fgo^cZ}Oiv~t|okc1z4tePD>GT15ZSR_PM4Dq6lQ;Z?Jnk)EF2*&{y z1F!B0>UeVPA-qOfu>31Y;?fe}fvjLz!ztua;5per&mRe56yY^Uuw;UeL=q2M0i zNiP5oHVVFi7o<6a*J=@54*Pou&ubgplkXHKmjSQcC3tflvh*VGI=zECfWJ+6XmD^# zU8lG}xG^%=d1sQiV>$5raluh|VSWEg!0S#4{`FdtI7)cES;0!s8TB&o`g4P0!MCpf z-e6&{aaBwx2yeJN*b({dNO+^Q!Ri>QPY~XCYw$eg@Q<$q-egyB(n6=$O?cD&!LGm$ ztO8!}PH+Z%{*v%!CxTh+m^7V)Q#Q z{1}KPuYwqVLWVbhcz}pWr)9V*;!Gl9@_8Aq4aq4YrhY5KTQ++{!D}GqUPtCO;pb9! zf>?1whD#t$Zz9$REgS){WeiLyy?855y*q7S00^*bicBnifvK*CXl@u_H?h zzl~qy9Z$s0Y%LrFv4@B~Ia;_z507Yh0L0#q7GBcbBT63x@p>aIyc%k?iFl)h7QUmG zNAw}$&9++jVGy&4*w;l1k3u>NiP+y;3+K-Eh?PVf9IS<3dd4G~9|Cb`q!!-yBz|+8 zh{NNw@WDPFah8a8rfA_eVJ-16h<9gc;ePm$*^)#YovVeHL9G!H#};bgqdh%hC=u^1 z*TP@J^b#UISgVDz;dR|3AU@ivh5v?u?}+$#mlmD@!tpkUll!&sA;igg2gIlEAPY}> z#2O+_pU}cn@cX_4j)M5&v=(j)$>&6zIj@Dw!fW?25MO?)g?B*mH4$g8YvEattbGr} zcQ>@~pgBHqjfktl7M}aGPqca;#1Af8_{b9;F_MVu9$R=CN@p7pKc(5iZ9!B&4&vu5 zTeuv2Ye~c}*|zXe{D|;jB7V)Wg}(yv6%oIMY~i2a!J!i%es5$8XTkLEMEudh7H$us z@kbzTw6%pF1TpYq5Px>Dg`F^+bP~iry=~!M^I)2Ye+SzlVzy7zKLtX_k+w*0`~dD? zqNE&Wi!=cBI8mCMVvC$@;t}hKa>!Y>$h-K_;fkMta>=>2$U;zih)R?TZIOPUJ|QYe zE{9E|(C1T7CFELLDspCl?%UbjUw z{1osuqVAA4kay(oQ=+n@ut%~$T_EaC>9R-G!)D@_pvp;)J@N@CKT+jnnmsZGRBfUv z$t-&$4C)wBm1VX)5_!@mz9A}G=GY@kVe=QFs>qN%vJbx8B+4%v*&|PY+I$vNRoTKG zc?6nAiK-^s+9Mx=`h=+JvWq=(9n{xE)sVgIkuAvkigTa>aMnWSj#l6i22suBxAw?cXue8R z3whlh>4T1No~V}chCTAzgFbPUC|nD5MBaV^?d&qB&JrI?(yLm9?Y1oY%;EkIh z@V2FZCshN03BMn~^&1I7p7eJIW5o{qSl1AvH_)7B9pT4)z;rssBk`D!d73^Ij8AF< z&$k;hftzOO9E*1;NbgGsaFhzPu^Onp9l-(8udlUs5R#?I+M2syVUln!hS@s!Er|B# z6Zn{<4B@vR8mz?o8aHL#Q{wbVt^;8wJ2k=eaoIIp_s}F!~|XM
zsfjGWZ$}WaP&QP2Z>0L(7`{7JVWNOIvWez#Z-{!^RGTZitek?r8Z z;YXcf3K92cX_32sO)yKZy_PK_dulnw7bNPS<;aM{4-#?7cGN;Lav>_~q%}gxJ_NPp zFe`tTT$nq$;hc6qeKy#xsbELo8X+Dj@6y~CQGZ+p&EeX@Xc@H7rnon+wj?dJ=@Bn# zmQ!q{*=6Ki=y5%VHJ20y9T738sp>x=k?(K|TGqE4zXOlAVxgBV}or~sob_tesa{s>GZVRkJW+Kp+z zl?0y!DU5{(^_2+T?S};Wqg)8t>XyBg6#J-E))y&?e)!NJBFTOl<_dIBjN9&VH-2mn z>`9nOV!Skd1FodV-I>-vLQj1`h#jQW*lv^ou4qvoGha67^&r`VdB1F8HyRh#>IBle z9)U2rBh2rOKp%$Sz+~j(J`@}wX>y>FjX`QQ1|u75@e6ay5JwI{HuTREu{#KkTqlh! z;Bw1JI|(QI>qkH@rf%32?H{<}FR6OZBft=dQ2zzE zf{e%ssJ_oWPBI(WL@mwjL+9l2Vv?2-abP6swhU?yWAKQ)4Z{nGdIViV=mUYK(U>(7 zIVYsJ9HzN5uw>>II~-}IVy@4`{hHm~DB80|XfD)0Vt-C9KZMwXxa26!-E?4*c$boR z5V3Qk#ApqtnaR#!{Pd(8pr41v4yeRHra2~z0)p{NHhLCJ2D zMrm;L+DUY60StT_Bo~Z7v9giP>_#2nip2;>?AVP2^`3HyRCpklQ)l@U>}Rp3AeSNnAs)Fv zb5E&&-|<8TmkSXgP{tw_p}{Rmwur@WWRzhMOSIxbF9)MbvGS9%VTzFAa+YH1an;ll zs;MW@c8#ux?eCA^b1c;5P-6(toQE+H&?f*JhUKMfX*VVVSBjHL!8;#3VJt$ZuR<`9 zT-XE`2yw~vn)^^^e9DhuraY zCHy_XcA}Q#FrzQfoG$G==D77K;>dyeBVcAxlL}+}2X6XFW#;AJ1@OFU5#WXb`siV7 zq{%_XCNT8f2v*I7>DS>hAtAX_ae0^JG99RtyWz4O{pJSZ$USg51&ep~a&NR-d8u33 zHQloUuU@I-B6g!B@VG}puLim<_E=~uZThwdLz*J@I zr^q&T<1651UgG{18T%Y7$>}77dMbjkn90iHaDtF*d027ci0Z`KaN-P_A`jm0z=@+# z;$2O5pGUi7$x$?p_oKuyEyF!CIzxI-%W{v167Opjg#H|o{~Q}MShyIAfh)~7UdB5h z5C%01{V>om3!&f6ZX7MFe-5N~%_>s82sHmY1p03Xdee}62H7K|kvySf??bh@e}wGO zko+`k$d8e|j9jN!Lc~ers6Dpm$pv`|ndleI#3x!d_fF3Er&=}colKn8a@>caYM*Jf z+_k4zCHJ`&a&L}4_P)^SnWOzkYL>+{9{DRHVd>S3jY!AKbKy!Yfk^g;Q z?TLAh-S`N&S#G2+^zRT(rUzkryK$|MOd0uItEr$$Ak@bcB2jOc;epvAo=+!j3Get??<3dK=2EVIhTBnTHaC*>79 zJb0)%K%>@R{SGiYP@0|WMg`zXnzcX*!$6qd0D;~L!7<9uPe_vxkG!U&`JCSdz3UJdlJ*T~MK?>tJg!zjR=&KRjODlsvV4ILM`HN!vSJn1!$WJ&rDEv+j zLz)njp!Hf8JL3l_(XMv=A6RXV%~#pYZbUj5X_}g{RdtU z;*ozUUi_tc@i#sEI#H~?2wKiTDt22b2O-(=KPA>pD;5vb!sc>s#UM}PzLYkP+p`}J zJGdz|Tbg^<0H-(HqEi56u68E4HhG6h;oh{5%ADV+5UMz;-%p6Ot{xifx~2 zTSxX*MzdEE*>hk{NfS(&itOb@dw(fghPy_#Q!IvQnTEU?FH&+V5g6+T+l)ZpgJ2zX zP!AF&Buf@k5-zSLTmlJymE#nDB92T(!b9l(Ay$dNxk4sctuFIETedpp?XyoUd0|?neZxBHg}*n zVlHM;3A{wcHzD`|2YX~?7$+o6mRF2du#9t4stDr&jGpHZM^>_-8_?{z0gb1XG~+s% z`v<{DKg4-3M@S=?qnN9yn#+Z`*sLK4U#sV1G}?g3wQSXd-W=FuoIR5@V2TirtYUM| z#sY^YWqz1y7$vIO?Cy^y!ZVt?RfFA6&}x{dZo_iPP0r737jo=A` zCS3X(KwqL|>b-X3t-`7#SE|We*8TvUiFjFpO+Vx3!un3UGVwly0QVmd=BFUg%OXgo z=VX24ijdQ?j#5A&wK5H4q~?kwF$8gBJ_@KI2;R1+YisMi=|(T1=VU$G31#c1kuWAe z-#-IEPjc*j;|ZWStuRm2mjJtqn0@TVa^Pk`kUqX@gU~}mbYHvidLfzjLy+Enc+Vq@ zPk`osfk6KTfk8QGj+_v3UN%&6(n!roW8~y8_FOn8O^}na7)@Klplphq_yX28OM$I} z+YX{DNt)TZxKBj)Y3{Q17CP>Bh-_Lz9+gHfsN_?P7&K|tM}yo#yMO)c#(3an#z-Xe zxuE^j75m$b=VCIh{Z$}^u^wUm76kfU1U&{Jg$~FQA=&b7B~NYCJherh{=_LSo~O4% zp86vVu8@1s)$Re|+>C6rw`HOJf#s(l(90rdN-0E;0wEsR(iWfmw?Ycl!DXXi8aMAo zgcjxC{Q$es9=I}i^aCl3!3gt*BhbeqSVLoSci1K*OLkJc@2q;?1>T2XmL2X&oe#t= z7?9mCd>L<$QEC_ZabU&qGEWY)8y^E#(&rBGEqKEC0ipgUg5LC4>VxzNNs~R5^zr@h z_%7;p&Vp4>H$|0Y6sH08Udbv2=lum&<7#-kRF|bks2XcvY(O~ zzIhdY0u4ZFu?5yZK=yVbs7L8P0DFXF%lj02LsjpGk@pxZd9!3V?6o^> z5%=44w}!_YKW;~$AzZ-u238x1hM;HQUFT_9p$@hicLFb($=cuvqb@?dIf9=_bpre$ zBwIeH_%mAd=ON1<9`eSh{)|=q8K?R)p8VN}M7Gm1c!=HD2E3?0N5B)tF@*Z32tFXy zS@4ID9Qml?&s5c)X_h}Zc!4XYtNzS@3$gNf%$5}|pP9C7q1Qu%HI&F?BtnQwPO`-} z86HL=u}y|YY*>~LM}(GGddmCk#wg%LGcXf8Va!ITFGSFnROi4pA!+gnB?C{Y8JLX> z#A@y-YM!4U_BVc1$55>Qfh!4J0V#~@2=jkKpv&!8>e2jVF%lvqOFpM0^t_c2FZ~xF zp|R0^xDX{Z5JV#wkc+5gHUpO53W44U!4Mj{pM_CEJb0()t_Os=seA@TV~u(q4IDEO z;cFTahuMwUz!ir#fK;Aj=HqWGnE9_F&<`LuI~6gPBPl}C?T_L5*xM^Q$A!4Fs2|N3TJ;gk;H=m2_9A>8?b&ExTF+ zN{}g2?pfq==AF!nwZqk^ts^vhtFNe`!W6lR~%Xo(t8tuFt#Af-+@5ik6=4q zO32M{gODt_PH|(s>c$2&`y1g#tPVC&_1SUCAU_d-UJ}7qG_`yMMhWrY)oOgcyiGN_ zovQCHL`cJV206lRgn<|FTKEToxpIp~XyuKeh2>K~axn`(Hk!qCoL11v`JV^3FX`7Z zmK4^HE$F?kLLiJi2>pi<3{P~5Y7LB|K-)NmfsoY#{nT~3Gp};|FtR(f?3*k z@e=r6DS<0W30zf5;0G)v+QP^>M3xsEMn~XEONehbjfTKG1%c3Q#qf+F{SO?*3~=;k z5F8@LXO2=1LUQB@N4)KQ=un=^A30p^ywXH233pckLr$qs(%T z!5p{|5u0STyG9orliCepv&=EqN$*gLc~R3xStgBfaD`-(>3; zxNYe!qZwrRtq|y)5Zr;qpDoE*%0WmYn{>K=ScKUHBsLA7 z#WbJtZu=|26MG$N`#T}cy&LZ~S@KUpmOJ`7*7k2gwwvC@QoFSMmrzX@!;xbCC3*lv4miG8%}j8pCq>K447_Y)bTUn0d

lX;6bRRzlCOm&Ug>@c9$lGJP-TyQn*1g|#2J(w#mB>0P`Jf!UqT zfzH2(K);S)ICZBz=uU(*(zYqxX}j8;UQxT#4y!x$+lzkks@k1iLwDMZVVA~WZ6~@D z^{o-4woB&3`_^uWmPvaM-%#ILA&t>c$sdnEpMjtab(b10^l>09Y~@|?CWxP+i#NfF zF0;FMUq}5`a(Uc4qdlauOLu=&1y{64lI>FZP8FBZcl<7;?^JaueW#i$3cyIpXUU=gWhxw6cpXHwFyIE-cB=F@V)SWDO@1p02m;H>RFbR9y@*m9lj zh83_=k9xO(;og8(z)aL~+TGhr;d>P%$wNO{a0nl`AfmRjxVtPSI84+*r>YhuLQdVi z1dCgi80cYZqjB<`8SY=Pf5Vcx=x!x%;`}LDtLLoX?tnwYOw`91HFUhC*1%cK-6Kjg z#DF#BT}!QzvzEIp4q9`Z#?FvCjG>H)CeC{9-k2yd(bU<=P>ug4=kdMbENyPa#ozS&e858*lAz`?VRJ>lktj# ziF=%r+})x?d*>9l3&%8A(!n|1JvmBrbk1_;M2Sw$+3qe;qO)_ZJAjVHak@C?yPHIb zuFi$-)i^}Ml5WnW?)g!oyK}jFP!~(m!@1Ip-vu$%dOFv-haa@8^>S`>=S6G#UguVK z$9|UAy`4MUcj5RUo9^S>3wN(^wmeANOcoD73zaGIkn%*@xwgAl;MQ@S! z1M5uF)??B*3|t)qL7H<$;~dcZiwN}V2x`#ycM#(rAz9j+%J{cW9sl;L{f15Gw zq@h@QOJb@=Gs^%a{hrjD@5iSbab#EaO)w(BO*i;mMjw#g;RuA@unbeEj6^a4i8vxp;i!KcqK)O}CHZuoQtOUK`d*n=rZ z#F|IQy$P5G(4%J?PA9h!JZ`z!lB|ZuRidvz z)?m_f6hq2Rq$AfRSNua+fX4P`$F6CMP+sp_UA7$t${H0_FBRtZ>r;_go{sscAFlp+Yd z3BtRn@g7Jpn#W|k#w=Wj*#Cj}BDKA@5{ywXRqiEIK?-9g!hFsOy|XKz)_pL6qt&C% zbtpmK3XN*Bf#*4mR|}gs3esEc5ZU>F?3_fPpGPp{Dd<mx`bXD~%;0z9V|6;^v-OP&F@ zw$tbWTo|>%ftyK_GFB=G-=N0vjMMlrCgZ~Ay6?lqn&N1B6<*0)+a2XNcN-6aL={=4> z7y}XJ4@IDlMG&SDFC9}zLeiw}iZ{!Wm_o*yWh$nS6Avee*APdR!W1%qeZ;qjNOR$o z%M!SBiTdAnPJJKnFjZD@m+>*Ba}GfY`Sq34xClIFCOtHN1NIxKHFOz&0XMy+2>-{} zb$~}zbnQD^QZ|*a*@OhLp(&BJw2%#;h?LMIp-WLvAoL~(DhdiHSh0f@J7PmcMMcGq z3Wx}Tii&)wC>HFfp#S@xncaJ{yWuy_li73ToH=dg&YiZimcPzh*vTWUYf3l(*rw$) z2b!}836=?vmUlqnKNZPxdQuEe2o$SAhbQ%&o-}|bZE@U5c3z9%N%Wb*_}2!yTHj3|JR8GLS*CBAg352P*|J_@BV3shZUfj6nw~&SBkT*Xyb_6j z6p}19!YR;3AfzTZT)}swoJMc6hIRlf-;KooKO}=_#%!2Dpjb_Fm@(aH#tfJdt(2KCBWlwu z2Ju9Q_P0Yak@~NNJOY*Ka)-QS&Kg?otf4C)Z!`wYvcqyEYN&SvxeC*t`51Aof@pO$ zW@}S`93XN{3TBP>1A2!2?D^10AYaW%$$Hgq_EhIWV|0D%ycCbUzBLc(qw8DqQ_%De zL)2{)wG^TVD!$iw;% zLN|GfQdVmC5MYN=7H}-{``)E` z9vSx+0?gyfBs(=+3^=w>2VpHo>hFoRKBMwXdbXxisEM2hQtW*AtCUIJ1 zY4RwV#BXKE*7cC4jVkRw$hrL~}S_<8d)ZYd!oXXIBlInjE85i+k-sKCw8WkYV(r%zRIoqgfFTnCI zkodnxvVkM5fG^KWAY0Y-*>&p2H;AHd-CQ3IaOFXOzcG?Y)UqWt+zfDN4o7)mKz*3| zp)Y(gVC^CcSpFeM>od%|ec=%`XgM>0=By=Gcn;F?^O5+MBKeSZ6~Zn8*(%>*S3Rd) z1+?pNmU;onZ;Zryso_n4Lyyz0_W`}m+&#YVhk&(RECBzJenQ$uzVOdc8g0&Ty+@Oh zk(Q?;@#iBMK$A{^NdzXUGKWcFr%C0$l&n)D^OH`#?5shUlFfnu)!CPy)c^|)7ZT~> zE6(bT)s)MLob1D9!+C(prBd1=Z14RBNan z7Ev97>hqvFX*(3Of$G11G2KjCsJ;!4;i;sw^EJ!LirGu}`3a0@o z&qm^}kEHZ^7*Y&F2xO}UzO3zMnuGR5FeExa2>Q~ka8DNP%c8@OxLC9)iW0y;!)K2z z8l&i3j4kA~(8O2Y3SYvam$B&eNQzjrIf@bpsS_PVo1tj*>{W@cepX{FiO3k`Bp(i9 zZAa-t?6yAkg?9nAn`O?IK&|k%Nc}e<+&(shOrPKNKEB(*r|=VBI2o|rU~=jM&6$bB z3O7VregYDITO`}r@JGTv0{Lo~qh;Xami-W&f$Eu$1%z=Zqel49Jl}xki>Ue6)bL!2 zy97x`sviPz1d7!Fhqy{3PR4sx5SJWzbqqvp@4+UD>~{_FVYLzg-AYA+eduR*Q21v^ zzGAcL58(tts={Ym)EmP8ddFuq*nv`ge4eaL_p=-7EGe2+c@)6mklMcVUpwDc`_$UcNb?CsaqL!e1is|Agco+E@*p z1d7$!4xLzQ6rB?9anQLXGNc|4oue_N4t)U06ByzSfc&Q-X~_mR2J#3rQ=@&dp(Woo zI1}=sL+Z28cll?dz%&~0sV_Vaup>xU0nOQo#0p=BwESiy{(F#o&-V5-6cET)PdE(5 zSNZH9Jq3dgp$=t@YP}DGw2vs_OC(oPTnO0l z6g3Bm`47_a4oLi`B5BW#vT0hLmq4*9PP5-B_@NEkyhdp$S%r~!HcrFr9Zhx-1gIuy zi04uYy@En-M)Eh?Z4rbL$X11ES&OmyEUmphgr1HO@(V25APp~sO)M&-w)X)IXFF|{ z7XA>hBfP%>jT`Fy#ghLb@u%&wtTcL34@wCXt6YaC0jDQ<@Z{~t!;+td2fH^)|Antd ztL|yx(*bL}@-DXD<8sZge-6kauw<`#q=nC~$*LJ{LS`8mdZvYMt;wKQ8lFMso^CL8 zW?J}#D1(d~Y-PJZu)-fB^?!xr74lDnYXoro%;DNN7^kQ7yP!mu|4bL!0 zH7d#9=0nSR4NKta^R#d&V27W5f#%$W1Yb2pT0R7ce=L%HvHvwJG+?9cFVeza*P!M6L5A>Ar2drMcuSLOH_Rk}V+Rg1-*=k117=32-5(%Ae?)r9ooV@5 zA4eMat~6{7g>Vk#B6#y*8v4*_P%;8vnpaur;n{#4v9qh~DiHAeBlVZS`_J%oe3hK; ze+U_y31_E=AFEmRC6*|c67Ki+@Ha^PzaiPlp>LP;JTHNn zs(HHo%(h5(^noqYvE?0^p|ncR&U!2I&S{D9DNF9{I+gAkET~ ztZ;vb@}Gg^avly0d9XfXITY*2xP099d&$*vyNA$qYHI^j8a)hx>C#X z^sparC=-G5Hw9G8+_mZ9lK^YoEP(zWX)3PLP%0zbGfIlC$6YMz}s; zN3`1jHA`Kk0Lwce@%KWKK{Nh@83gjxZw{}1cY5^)%!nFzgkCL0=>VVFRvFyUdHe~faMP%@js2^R@QBcj65%aGSxW4etw%|INrHUGjt4_L54aZBRgx=_++a+ zkrOlWvpkW`s#!*TS#;`3N=Zg>)`O7|)kzu6WNoSsDa|uNI#5qDP(>O3ra}D18%=4D z5$*wwa(SW#5Mq}WJ_C?{JQ6Sc^Jj!70}g$|PWwVY-!NvaGs24iYp+?r^524V51+v`w46uC5N0>we-YqOa<$0_zgm-Phj4NJFM9r>_O==RACX)Rlc7U~zZ)2465f;%?iFR02VfM?oOMX7@K~hf6Oj04 zBYBz;y9AX-AYWbNsJx4vmABAT-hC*e7G;2IUk0qrWdTi_PZ4is2;aMe-^%d+ z0P44dH)n)@sZl1!{W-l$L0X=H#9t3d8he08;2nWx>OqHhYnZ> zq8bhX>fsD5UXKHGJzoVK@hTvYt=f9Bp2h`tGH-2%SHZMNW)j;TuYyzSrfEtCyb5kB zG)O641^&k&>LFV7c1CzTU`HLj4K%06K6@F!!B|@GQXEcowky%aESW&fwjQ@YOYFId_mDd=Jv{2a))nLUJcr z?}twWD%710pYC${v>HA|Ex#K+MQ4roz^AAi_tK|`8~0`4%eVPo;2W2GNLpux8vu3$ z+8(NP1i=b-M(VFXat;HXnVIJ$kgt51c9)!%=@?R_XQpJ`8W~|{WFj(`p>&XKIg}Z` z60k#?Y%;D!o)x|yss9NiUCEjcMFeK5Y=@#cPDMFT6uq&dZf17YbZmIb(y%|%FU#e5 z`%%5QnZvU--eA676UZDR4`*Xi@-ipth4gj|g)39uzpDu+W%@gTVfFPRfJu+kXZqZYNS z4G7cb$d3Arj7;$XIK$ARh0JhYz@aPHLyrRVICFPo zhQ|WdWm&-T&qw+v7db!33|~}(mUA^3!q+1$zXgf^UL;ph%;wDgUIO__z2dnmTehVU}1>VZc#!WPbk>8dp8?QhZ0SsJU&Xkd$TxGK<6B={B#E%ki zy<}%*xB#$ixMTUCJqWl|fEM-uID|rXWrq7i`DF-j7Ep62V;sQpNl5&2kzCG|hWB6u z0eJL|!=rbd9&Ld~&)nd{`7PMG6%`b9ZyPJ<70BAdKz^7ReiN|6)(?SV{R?Tin92GW z$+gGbnf@cl{SmjF;kat}ShSd!obeTlDoI4!nJgjbqUIn>BT8sc zCnRbC(7~_Z@b_f^tT35}?D^9T7*|!{Urj5-d9RWVyq{|5Al&frF4p`?O1auI^bw#Q zQad)f9R~ruxcc@6i0__KMHx96ugjsg@Y)CHtOAGcua7m|}Gd%M*TX)d{YeX9q z$u{JXxccl`e7#f+ZxPL@axJ!)zXZ(573+Ogx3S;&tb1@6qvZ+k*UIS!0s6Le+=&G`Xm^WzXz(&tQplY%ApV%5S$B zv;NP=0*zzEl+i?Ga$iEO z8>57l;n!H!w}H3QqzfatIh#fJO}NA5EO^keGkq`x z#!eodZH;1X7oC$Mr^{Ns>#k$*9^;lLi+iHeaou2h2Das?I$PHN#8(LdT}LH+f^eUG z0Lk>5e3o1pUNyKMTH!CqDkl^s6c*^s{(#cI1%Xf%Z~d#{5BB@IR!ACh80?C4qV2 z8z3`$BT<2bSs*DP5Pvbc>RGZZh3=|X2r+LUlkk?ANOm!gQ2FP8PKx-@_UrJEqSrx6k=lYs&aW8Me!jnpcE$Q)*|fl};a+I+=iBukkrX9=QJg03V=sESZk%5<>s zN93#cd+SxtkV+`Li4Y0lCrA|m6czr61m=Z%vg|>k0tvG~Qi4!b!BnuUodPHuk8-)7 z1%xE;6B0^@5*kQq6{%IEhWWHr^&+*&*?_7DT}o&qA)zuED9{Y%Jv`qzWX%!0s8|$IH)V$}`f|J<6ebv_toqDeWTH zlX}j|?%N4H9s4fNm~7SeNjT0v+%q;G_kv^azLu7pU5x82sVqDT5vqC)Q2BX$+Sz?q z@#R^ym3bE;Z^&Tt@>+n7P)*CkO_L=O!=cwdY+j??d_K3blZ+E^%d&Rv*uZq4jBd^gl(H!S%bjWs-&3CGrwrD(F-TkR#==;zq z@A=ckz>^;JS*@-Db%0P81LX{+q>^7G9kv&!*jpv`HpY=^v3Fq9-r~O

Vk%Z)%B8dr25kC*rL}SsqY2|O8Zd!~hp_?X1p10}pSDxePrWt60HPY+$1epw#n@@LQW zT>hKTZ|m|`6J5LfpM%aW|G+;ymwz6vY%;2Wu-fI{XS3(>e}yaS@;3v)3CT{Nv&+8> zSJvfM=Xoyw`Jh{uzXEja@_&k3T9^M;$w1%bzeiG|T>b|PKrcss^SRzx|7Rj686~k+ z_0~I&0vmSuC6<(Ly;BR6bd81MC&8qC>zzpehn?d93JSR1*#;=#9zzSl8t(N*Og$rp zy=9kQqG?=hyZjOzWmbgCFQNI&N&u5%R^SQHHcd6=oK^w$t^blPf0Gzzq|2}RZo%a* z2m;zLyb@_=AO1wnYXT%PibG=NB{Uz00+<{QF@x%S1|4Y_#4djm=RPTCo-g)`|}3tQGITmDP%kKyV^tF6dS(wt%j+;_JAj)rw7WntiSK zx}-*F#byHtYsED&H%BWW0KY-GcUkH?)d{T<| z*P!*tS~D(+63CISciP1zyS#EeZmZnR)Ur-qPPbj~gCM5lW~icSL%EINAu!J_juuB_-Z1Hq#680c1X)CER# z(jZ&W>DEuEPG59-Nothn^fQ34=xpQWijKre(fJA^3yY4#vgj-WDv#($FpJLl0Ea~< zfYPF~A5b}>qjz__M5*4r84)ulmTDp;s!+vh^X$Jjl0E21JcYfd!WS_9@d zb7oIXsh`M=})^i zPjz(F`_z7uF6JWjhe>yoa?fqYrynj8ovIV6&k9S;G? zyEl&j$;pnhLF1ThYtYQOEy&eUXB%0>kEkVv5`c5ft# zf`WQy3Cel*=44#i-5ZId(4gKKjq+gTq5{2bYxm|EDfr>EMU_ljG*C-AZE+rW!J)zV z?Okz#s|5%S4JLxlp}|C8IW*`7S|CLs?~Kp@hNfoQsNI|Fh47LdkL^VvW$x}x6-uK+ zIkS8781Bn6*9d5CwEcnUhhEwK+yz2839%Cgh~2%BkbI$>#6*U2wKNtT%3WCOnl#gX zxDuhtzddE ze+5@JE3tjkhysq~biom@INrH}Uj11K>tN2-wWdb`IGWRKSliP=jq4qpDHzk=+MS^t zoa{wxd+MFrLFaJpJ6!P&&dwdA^{FPTwm!vMdDiDXTv^AZ4hXhBYfzJ|&*?x|>(c}T zTc2^DTkF#bx^`UZQPEnTiDuwlN{t^dohGSK)@Ql_gssoLsa)$LvC{gS25i{+NGw~Q zJ%Gw%eI%HzPYU3$^$DP~_4x#h30WTw=S~#E=5Wr11m)erk#HK=U5NOTlMORv{ zMna@e1zqy``*H9atjfBX_6P}HP zUTNx5h?3q&(Ef>iwa*e~Yo4TmoxMq_1vYn*D&&Bp-A@V0Gf5JXZ;~V?G)cUZP(_2$ zJlBKCJ?b@0@?6iN21Y&J*+gyWXyF<#fY;cLrE-m_%e*!A8xXw4j=&YKv6pcrz0c|L z*2eoxZiuN$w31jJ!yAZq@8YTyDD}=J+=pLs^8l{;Xxc1X*_YhZq87h_crJX#YB2@W z7N@-EC2bAPexdU4<^;d2t;z4jBJ_gXSpE!DE9jg#c@K2!y=E`>yw_}3>AhAHU2jGl z4?26V%W%cs>+iU-xswLMYVY;!Zl3o#cWddrHUq)l>n%XA_c|H~>%FQgJnuCLy7gWw zK-b>u(Wq#>*VS?o{M^YJNsaPeKM?$tN8?X|r3;^ol~`+}>zz@+hP_vbW$(2RDCy$~ z4@QF7dwmx}4tse4l=fcl0803I(AptJY726W-Qt__Y`d#{0`SuH_88;p_2 zwizRlTVRZY=3`6%lZP>_K4Z4sPP+BkMIK|01zj-af#A4v-TKBLpbf@IWZR69$Sp8N zLh~^ufXQKuNwM!B5*@y2v3ZUSqMY*_wA*40MHLvxX^uz0K%3^MBf2&eUxChsqDL>! zQ0$K@Ybcrts|`ip-kzaYfh(KlP*-|}q7^mSP%H+*8j1=aIL$EwbZaQ8LDz=jX;id^ zqVtYcH`2mjJ&~2vC_~Z90K#dGm-^%y3W>GTj?Fn>!-hg)Y2tBs3#dGXLV{`P@%3VW z!-gV&!sORGzk)H5hGK{q_LdEWMANw1-nEwKD3KP1LPGP2bO4hh(opxbYdyk@NAEUi znbzvwW;;B9m*g_OvsnI>!HLH5w-!V3p~gB$R$^5QqSN!|0@Z7K7N~9%If2UI??99^ zI6rI*mZv7VIMPV(dHx+GOB_`I*ivT=e1nv(a4CK(OoJ3Cq|S2N-RWElD%qKT;(z?( z=iQsB7pr4Qe%@VOC7ySmXj&j)<>%e0qtndDvY!I=r0gA+tJykLE2id9j$lz z_jQ%&DhHRq$W{ba2Y(LW`fIh-MzS_0;A52TfBzCnE`P~O+xa-EfSJ1 zZjqQ!+`_@-iDu+l-l8La4ld`5DGR3(0>NdCY|#%c7Z_?A!KH+3Ik>C_XE9ZIb~frz z>P=BF{x^rzM*36K8aYLm%Hc+bmJ*U@iXFNHh)tK1hK!~IT>`0E$0BsvE>-hWNi6>yt9cd zDK2b6E0~_#osCu$Uk`BD zs(&YCL!~TElY)ClU{5E$sBzy}-UqbU4{QxG{=yT{(jajF)Q18sd%vf8W z6(i;7kTz+Bsh=(ZQ9B#eK|mXxzC_yjkBSW?GKxbYHk8nO9137^IAmf&pF#H<2AS9p zbdC*w23;`b#NfDTX#_vqQeyz*^T@PGd&HRGw28!8*3>&6l;tiBiRGoS1gJbqLxOo} z%mX;QGy*8SG{ypDmj(wzXBbyzoY9T-&NXmitZJ0yoHd({avKb_f|Yz!O?!)0HD<42 z)o9#E3Wp#S=G&C3(T3HGRRqF53?Qr-cO8&B{Sqsuzdf*F%_y-v{U2a-d8S{2 zdHRBehpzQQxzUd!JL6ejM?ETj}OVLX!1+tu_;AE6rDM($LM+z#bKp#8P z;t`aBPtb;yf*OKqDR_K)PYNavlv2kw?}4yVpsq7gus6t7 z3O303_U+>)NsW?%&3UBYpdE6hKw_m7WPuG!fyA;De23BHkpc;3DR>ItuoMJPS_&=! zDn|$KJG1seh1}VdND2(}u+ z3kGoY&bK?tGiwrM1B80#aiHu5uS8LdQ16_Naz3**30L;annY5hfHxeVJalFay^Rjf zINn=mIMznIXCj3LYDq^5hk-vFDI7jXMhY!JaHP-=bdD7I0n3rXMqJ6A-dp9J5h=iC z*JOe_z5Ebn_IkKW&9Mn&)a4E@?;2L2G&-^~XVw;@FXqe|pt-?!gXxF14bhREgxHA- zoLQ5Qe36~RL`HVCG!`A%9WmI8>;~W}10xKLKak=m$+b2kJ9UFMU%!F_JYRpJF&o)c z0>SgO8g!no6~OX*T?d+s>{iG-i^#4Ptzdd+{*Z39pJQqSJ-owb61k=&9oP9at<~Bf z%A*pwE!46;uQq6BC`EAP4o9C?yOE7ny>m9`oXC9{R~*%~A0n+*HDR^Y`T}%*w|DJO zX|?KrV5{{25Nx$30b#9H6A)~*wgKH*tya*r?{YdSTC3H$A~KOHsZmy|mjQ%*m-C+5uN~<*y*s#@-ShiYQ1C_^WNibWj^%!#4Y6Vc*YCQ^6$ZGM9-w-kE|3@NMplMuN zNaPAMjf|oiIWC#V6;K)%LBpexUG0xi5k`!uffKo=A)Ux&nTE2mvE2x9qsZ8>rEon!`uW20}Ssvx+G*Qdi(YYD@wvLXv#dCDN0G%D3 z9Y%VN&MCOE;dv!twWG7|D9_RP8drA5x&{b#bUK61j?QDavW`vz5bWq&0J?Q_nnBl& z&S$u#b##uE4D`eE`H~vt=$v5yVMphy(YcO}#9GZ=?<@m0Y~&=C9i8)mk`93|a}vys z&VB%gU4j5gJ38Hg5>5e>E*y3`+H|QH_LdzTiQclKBhgV-NjN$Zn$Ic)FgaEUPB!gW zt6O;$;L-9iJn4Kae~}nxq=U0U0-_w8)j>cTc3UFt>_<5`5*fuIG4m3dk3#`W4u_aQ z6+VMz8wPRmx*Bv&UOx!BaA?*9$DQlYd|&|K=d4%kn!7M0*0QGFSqyA=VMr`5j2S@X zSr`(`3uAkL!wVyT(hFk~25T1v2Y`zPvu+>9z6sKn1INm=r7Y*P<*&F`y$dxW zdL9{=hZd|1q;B(MV4poa8TblURt748V9VGEbe4f-xUw=(0|d*!`Jh`FXaHTyz^AyS zm4RY-^7Jn#1KlJwN(OouKv)LWkIR(-iIp<&D6nA}kXV+1TA=dCfCRG)OaeG80|Atl zfo*`wkpZ1j_VPRt&pp!v)60y%Dj${hJf?^$NGhLU_|zHvb>{4TWJ=AQg{1O-Oj3F4 z@#azK&&{LK^FTn>StUM?J+s=uqtZWu@ZrvQUg-1KYE7uw6Oz%ny-Iu$TLVI)b5@nf zL$5b^=%ELgJoJ|$58Yroq8-0=l!v}=f|rNBe{Y$GmPpP+p9&=Bq0a!4^U%A2#&OtZ zxZ*fW)l(k22!Go=wAY&6=JZ|sdgtA}WFA_gte0Q!GyrAu&=SRY=o3)RdFbJ|vUzBU zhS!9iELaEtyqnYTEEjmPdtW zwbZf>&$>^9j`Q=-O+?qHi;e=F!?TBQ#d+wTab=B=y2CR<|DNO-q2u?HMyLV^HbOT5 z!A58}5Y`A)1Hne90Ca1F>Oj{mW@yxs60kUg4qZ)W5{766hLVs^iQBdMu@|+S~2V`hi4K^<7zt(EzvYG3Q**@ zM0h5lG%kXMM-{+eRD=;@;^?CZa}Fg1cj{JfktUtPvxQ=uk>OdB1Vn{rD}sPF!ZV4q zvmX_nNn{jEjeS$o|RI2YUX=p|}$M$#lu{HvN-2YE1hl zebEH_Cp#P@{gY-O*gx3>1p6l&!7cVrR)8k`lWKWq;h&_I=;_JvPbxu=_D?P~EouMc zdoS^9{S#Rp<)740%i2GgiSbzfq><>_Ke-=t_D_Ds75gWnCQJXMm9RQd(rJq4pETmi z2FcmGJ^y4aYO;TF4iMHqsRDxilYKz9{z)z9+CN!}iq=1AlnnI!lV>C~%0Fo`fUtk^ z(80O>iNsn(T<At{z(^r!hKUpKj8R?&N9wq{gDF38e z5YUDhmPkAMQT~ZUMsY~YyoBcCPymy|A@)yNdD@Pfi0}_$R%B&}}$kImK*y=@D&Z)!aQC{z-k1N5-sMKK%(etDZ`yV2;Vgn(yR&);awBl{JvRbhj z2#(rbMNQUMKOCq$lP|$M`2_%nCqIDFlm8YNV<(@KBL1-qY?Lyfc zWuO_iv@%c)E=S2g9ntg1z)0M|M($07)H0Ah+>?QaaAjqn6$qArk5Q9lU;z+T2D0~h zGO#!3RtBm-*D`Q7Dq0!H4i`Gmmw|zj8YKf21`w8k2WRBUfW%4}I2+io3`i`?zyzT3 z$bba143q*KmVp3D%fRPgOpXlb^s$$oiO2<0`gpks%Vs$T;Z2(aqPK1y5W7epe!kee zd(-owA{tTiuEclGPWk-@N6n+3lizwAKf~X_&(vl3xt~hgW2RL3TXCfHUoKaw&>4SB zS5>C2Jhh#=A?c|1j>gy5%)g36T*U_9kAfqY6{%^l9pZ=M|NHP-Dpl~}BSmTju43a0 z3m)3Kz50-@_e>Q$zI{7&J0g+TUfl{-k7}oS?2hXR6$N+VTWc$);d-A51qa~Wo}EsN zso2D-#H0t)s`Fz-Dpv6~T5w!y$DJ@Zrreq}j&iBGdp%uUf)n?u-L?~B>Sx>{Hl#1k z?mC4%(4p8cCzetUbu?K6s!F);7pTqmqGSYh(J|ELK#e~D>Mo~JT|>S9K)eeV9gU4V z{Zq%MZn!_KK7Rw)QP;fbQQbKJsKoWp$J7xRL2NXQ!8B8J{IrysPSi0>aj8%xUW<2B zD~|Ox=n4&T++Hkm@)dXVTMO;_4vW(AlM+_#0ezqWikKX?xpL5&G7;$yLsp&eS4Z z7C7gZ-f`n_z0^^iS9%eC z&n@jcHl@xf-R6Q$YC-8Az?@aO`TS1m%+e{KoKd>)l9W2V^o@%;snbepE={RZOIOu) zQu9miT$oa)ls^1pO3f?14!<>}SAsIPbT~>+D%~Hyb4t&}y-qA$eO@PZLg^^9c6@08 z=*N}b0{XF~_key(>0`Lp(WS4prqofTzoRF!OHV^bKRW_N@uK2sa5)F z+uKuW>C@MMwl}Ue{d+O4{!yP&_dG{ew>6|xcxs$4U`$}9b!qwIK>KR;JrLT_0 z)s^~c=}n!~B7OBYu0DN>YHa>TCw0%ObagVWHazyz+IZ=2@1<13okaTpSM~bpB=qIY z8y11~4X)nMSD$~IQh(!LJ5@X%!rtXf{A@MtxOU2QiZ8--dNF>St01dGW5qY%x@)(Y z&ljn!&pfiL+NR*_t-7dg#qT@aJ9bd&)3e*D?t^w#YS(E{DHjaE!st0*3L5^=agy=3 zA;R10KYulUx`jkbQ;kJfHpMLtm&aoacijYO@2V?h-nzFV_h=tkrth8|{b`AM_9l$> zD6diCw0kP-wo0EqOsO*1jp8qy?8tjMGVnMLs2j)>T!=S7PelVK#nzK}Bu7$5GoM}^ zS95Lz`Q+Ftv}Gney?Pg=o;(=juboU~oq^1YeWM||X8OKSkUE0=7v~(8B-EiVqXVbN zRx*d)ZOHRw&CH+GadiOQ^Yj?(gMZJ5(BQ+=;5SaDdZvM#6`P?Ue9vWo+)t2iolN^P z66&-SxaT>tmCT7AxmMQ9>@+v7rqMkY2DG;*^< zXIJl(R3}^j@;|)k)GI9e^lV3^{%}?CErzZ#B@Yy;?RHJ6;(x|&go77YkXJ)O`jUiv z?qp8zaJR)se7L*3a5L}yyHLH+9s{q>X(KcA4O7;TTd!_!M}7Y@x^su9r!qfzD=2gPgl*OIhaUWZxxI}A{n|GrYpWh!nLE_af8sKLc-wUM%T6*z6$(mZi8eP&h41u4rs4!1dPq$Slq?yowAp9O{!^E zqXWGRL<@P@zSk9~*+lMb+A8mVbW&YGE3i+TAXAj-O)o>U)FQQtrtAOEL>$^8YH zhgOz8BB{=%DuYCsD*GPn(B#2_%vH)ST3w>jN1)e3G~4wMc|hfR|6+=U#c2k(Z(S&< zpS}gl?~ub$>no@1u%fgYc_glfo7RsZc9#FTri95O;=~_rn2Nadvg48^>gIo;ue+FP zgwkaO@cj2_^*C9Gkp@81spkejO8tBVqyRq?Iy?GhF3R4;M~3{S3U2D^F}+zkJwTk-kvKD+g3uV|>ni{q-# z=RMmiVodQh@xneAm$z3-7R6QZweeJ6!WUlTDt68JF+V3W!U&?gVQ=@K(8`wj@ zs!Z1*#$?|Ze-Z>)rpnGZq`ms706pC&t{tk6;85}0>3+iBdL{;c%Uu@hPHtM~15&E{ zIom1Kgq72MP;cXS9nc5E>wn2-N%aG9`R|yMehnmYq1@+U{j=bZE>Ll&4_2P~3xzJe zBGEhX2v%k{w|jiR1>lg|Gp@Ezbi;pr);*q74-+W^uF#jlf1p3`)$u-$LMM!Y{c+1E zh0r^(epV4$*cj_`1{&U*P`|`fpUN`x$FH%%J{N4)UVT9&n-CACAH&UQ;kqxzdMEyF zby3@m4~S8dg>-)h|LOX_(O8Ob%g#NN8bsyoaZBBr!X&ySaYvMo3bib9?MS93J;M5QTPB+E1dGaYYX2iLt?mg(+gM*UR8 zZ7!B&U(mfX7yoI>u90OVQSc?sWAD_xGk$4D>aG@s^gb2rz`FmAWxnztcgOG75FXJ$ zs6TRG-8W*HudioM)xB4?k{NV^AwM8%W(FL=-l^Ld-z@Gq2n~`0>%JMwoaR9ujc3x9 zi^BjR2i9$lWyYPx4y^mQY$bD*M}AV)%q*Y74y^lZpev^>WCzx53X-R=1M9vNXylC( z*@1Oe2FMd9vjgkC5+@NeQ=S><6sWzYLO5OvkpHzKd#dj10rJx)v%Bm5TavTSepIA= z3->Kg^t2S~$;)ooiX9U7ZCR+Y*Y{+CwaU*xox>F$-S%V{I?Kurf#F}bU9*Gs|Y zh4wEj7+v*^pB3* z=nz>^k12cH?+`#Z`0jA84$IyN&FuKQyBNC4ID2vw zJ34@#>5<0-(5t6+&~dptL3WW@J7X79wy!K>o%xAd$o2M@WmHeH{fFKLb%;a>wqNvJ z5jS&a7@#sWSfZ3$a1WDZmhG8IV6O($NC1n>QTuk#L5w?Jmg&koxLp#347fBBAV;xw zI|IEe2P%g0-pX zyoTkZQFrE`m_aY53w5C8E{*Js%548#M+V#*Zb4<{jV|G``@?0rrz-O@x^mVNSg{XA zwr-5_)$u|`EzggV6LC2vLbv)tG+xZcv6u}FeK9{&Wj^@8pk9hb35NEVYDV<3gz91~Q^ihex7R=9mftI6?wMN1i^igPL$1Ix;Ikdw*srQ%6*$#{^S$x-9dT zxlz+=okDKmjQl96JeIWjo@rwkP9rsb8It@7;_jgGy-@Qv*T}0$RWgDlgFH+Yd&F4BU z_l}Y#s{Cj?ynhdo3tS?Y0Y2|h+qsolP&p|53CR`86uK|P%I9Ne{usJ0lJ(y3s3oFa z`Db_&(j|mVN$k#e|B$A364x0evFvOd4JQ;(9jy`wiA zOoRk9!0Xh2iZDQxxo|3V*aRRa4}?qQ;mDl6z%sIJ9ki+hA1v+$PnJ*I>D*ZU}& zWy+LotXR&K{nl(Guf2gF3a?-%HKg)a5&Ax5|=t)q!w4I{B}%|F1kBZ#0)8) zfXQz~_RqaHvb^l)-FPFweS~kT%C=fjs5b)KM@>g)F4YbvuEopb-FSS*6S1JWdViO@ zJGTCcSGIe9caHD4HIjmH)wAC#os_#*-0AgA-@Vp zbcvtfxEE3i@lyP7*0CG1tMS=R`H;_x)cZ(^#!qxevAIi;p4C69yd#SC{taKzJt?PX z#<{FH&_rxpwusxf|=6Rg1fDxcD;P&GmV z<7YUHR7?MeRtKV-oXYrl(dDPXi`B!uM3n3M)2LMWiqS=C1dL_;D(A6Y=r#SQG!39V zvZV2&obqphC?(F+Ihqj~QC`2fNEH&|8m`B!-O{c|ZHC2*U&rjRP42Xyyg(g5H@ZPr zNT0RRQF~AW$2jTBas3wE;%G;0llUjiS)wAY=ZwxH^xQlZ&)rh)^)cdP=DG1nbv1T@ z61&Bp0)fe{=5lsrd7(O+$|f1OOAs#1v|#p{w?kXA;`bmA>?EJ3vSqkbX@XG_J25q$ zeg)T*sYx6X&uj;EqU#(TUu)}pt?Q7Kk#0^*i>Kc}9olkF92(DT7_Yd4Cxknw_e+qY z?86ze#N7CYsK*^q+3g^kXCrNtpiC`|)unE#G!2bX{|P(?x=mssQW1_jFIJ(g?x6Id zn3{hGly`M3mi!V(HK^_b@ETh~?o5xQ1}Cyk7v;43Lhmtb3+q~*T~w%h*)Hx-2H)LC zH>6z#m7?1cGunNX@)G9lzD$in8Fi!GhO%GEn9c3FI$Te;z?F$j#FchmqqE23uH6#t z65Z!Q&WFzK%6lBsW_DFQUg?Wl^*E;=elxLKaO7+q4qH_uMuOlZ4ox}^WC&KSzG1$rnXmpjuk`K%`jhtO2KhQ`#;3D_s0 zu_jt@2Cm<`;8WtIf@FpoI*x|Qq?Zlp6e5+M`n{uKe_`|=7trW6TBUoTj+Vmb3(7Zm zh))WL5y_pYPwD>n)iT#qpoS%u9E%fbi6;t%C6?=}-s@f66*@|tOxq+_$EMQ zyZ%*y8j<+!w^Ef#e&lOue@AQ=+UdC)*yMkmKE()QAE)buI2!A16D2?G(*)n`exhF# zD;zlvTN26tImspv6#w-L|K+|+q{Lloct0Zf+ne}X7BPCWA?aNkYF72sZ6O**(peFEfJX^CikE05g=b>a{tLpfLt<}bN|Wh z92&j3P3Bw0x&LIJ0Qq>6`%m@{kZ&|;^yENo2)ssmnDltE!s)-gHw0HRIprzP|BS8LgYtDWo_jYJzOh2-9cNeOu*n>O1*W=ED-s?j+|q zw139^(J;nlx~}E8FnOl-A`F1ADs%AtrtCsl=HJL=)TSi+A<4_~qvRcHOw5?9lX&ew zWtw69C>l)OAj|9>8Py7#t5LV+N15T>aCxD2ckl>~U>J4W04ACYQ1X5Wpv7(gfB(su zrsN|M;4fB#8elR_$)_SwDl`5vPVgjOk^s?>i%bS6`I-cXj+}swP%0|3^5s?*!SrxsScwRs{ z0YaW&(RGPT!EZ73E1p^?dONWh^}WW=?N-F(j}x@X&SaN-Bb7PjvAFu2s(c!#^2p#K zCV!P%<&YIg^&M6DuPLLxx|0T>xpW4-dEiEL_}WCK=Ix~3wk-NqG|jlordN~d18QSq zP8*qDKS-+H*g`G(CAZ$pr<3}`WYH$UC)4K42Mg3nxOhcyAT5LXX-*fpn$fy|T*Z}` zDW__#4E*UzWpOkcXB()tJA*R`8W&f^xtt&k?M;^+b?sR^1n-6b-;Z| z)qc5iEgDD;M1e|EEjnS-{xPS#ennip56Ni%v_Pozi$EVkkk_2_8@Nu4HMjn2pM1Ag z^46++U>E<^9dI~2IV|Vaui0B$1jPJhoSxG0AMJkxr6%+FaD$K zj~D;lS>?xnp$?k(@6XCm{6`&8*;So8*!WL({vLfF&w)Vvmp$T)t<cGcOPyJVjkoSU5q1h zy5tb2FgA1!aF3(3_)sSm%e?y;=V^-%cUGbQvE=JC3i~X;zD{Ph76Ykv-qMhd36hz* zbzEJCeit9XQ>+)(E&&L4r!_b9^y5h}CvAwO^N z6Ua{TE@DllOQRtVO>_p%N#3i;clGr17B_1$qdRZw=PjNV=tbN4d5cF;-Eo)eMh5ru z^A^uqa`xwLB5y(Mx-SwO#^|JZa2qIZK|=}T0K$0-0tE9GbEu(U-a?Z&_Iaa%ryK=19Oz#lM}b0-qqu?^ z@^cjQm+U5T6q>}{eD+q8fp8MUc3q^>b*Q7ei5$hye;PzQK{Js22eqEQ9=~3WVw=QO z-x}|Wxa50ZUjweaFQVpnUt_V_RHnnPzW24wNRozeL{47>drci6?`vas-}@RPAd3O< zysvT`oHgFpeyHyxx$#^3``#Blqr+t5eZBg)?|sQC$sxY?l~d)3mwoSx%c!sJYv_|o z{}a9OysuU7_}-UonsJ$fU-!MQa2uKZKJvYL1^YDXd-CWuc=;7nJ^;rs9E5BDPsnv_OK-;`(8OST)coq4RPWX4$p<&l2|D58rzKL=jmyz zk`oQ#pQrItJtZe`J?`Li^H5L8TuXJiQ>VXDqK+V`spTRP7&Z3WiFibrs25r)@3xLz zxjD^67l|Uh**f<7xB1bSl1puo8ry$AJg|#Bypk&{)wEUcSDK5i6h++DCB|TvT+K!L zsh=@74B|r-CD&R(D*E&rb^=RoG-^RV2Be!QijQI^u;eybrky|}){iBpuB0>jbVYAo z!COToU1P};X%>nm86U2so1wt;Pb6>xn>@d?*w!ESh)L1yKHA=l?3YB4j+^N2jx z=WZxfuk<)#U7~ z{}t;KaeB*!+I4RuI4r?`4l}L~jUbO}!CN*22)aI}QA0u3N0Zp67>-x|8rO%$lcXZy zQ^56U^bnsE(9n`+`v}kV*{0xDY;WsFuV389JbHcJe&z|F`u#Bi`{?zmet409ee|0C zbYCZ0nrh@cdacXP$8A-*8NsNIX5^#SemOT{AHB8(@9Ea5V>ypr2SKI@|IuqI6^~wP zaEqnUqt`x->t^nrW1grQ9OHLG_yE%oJ$kKacLyK6_Gxk)^ysxN_|4vx9=-Ny=C1D@ zY3{nGysNI1nbGJ!dM$dS@1E^6iBD(iN3V6G#A&y64`TOq2iQli_kU14dhK^rWj@3P zmU;AgCTcp#LVU_c(SXYh^@@6qd-XZw#{i&ipk zdgNMJGqbM7fAm@mB6H0p{-f8D+;f`$=(V_g=9szuqt}xB%u)WM*EA^}Yi~HyMEcjo zB>AOTp+~QIBJRScC(WbR0-Zf(XYuH@Kkq7g&9UOqYdvR~eIN24y-x4xO{GhXsq_Po z5HjKP==I|s?zR|-4|kVwnI3QXk6wq{$Xx1`HRRTNyvl#{+SXH<-Uk@+Qc*=^9{JXP z^je~`8w~m30Q&Q7{YS4yLS~JKW~wrV{B&%rCTl)subJ7wK6W%uWFA`C zYt{DAYrjmDJzIs8D1578JbLYuxk~wY+jQ_Ay(YGExgJpY=6R-QSe#^q`?h#*8tZZ_ zKb`f$qt|PS?W5Pa^}R_B%U{~LgZJn)HOCE8k*ixTJG8xh^jcRVvMw`#&dAz%k6vp4 zO_Rym?SibGF2keOwv4lV|E}oZKYHyqtjeDJ%07BcGaGv9nv=?9J)gIaUTc&VsIrQy z?W5N$7EesGk6sJl`d{s%*OrX@@gBV?7xq}9`}c5R$cySe1n(W~h6AI0p53;+nu9+Q z&nHyRllMpZyrb(RKgKycw*@~cbI`SX+9J`<{SpLO*0YB26AfNvPPn_Be&92)zl7dG z20zp92Tq|R4t860Ge7IrJ9Or>N#am^bFI zsVRTr_NRHgpw1!cyNpi}B+m8d#1h1?6v=IO6ka;jI_k48O5wM@eL1DXW?7E+8-|DH z6GtbKbErnyN&U9cyEciML~&i;Jb&@mIMg;?&niOLEl}I*mrM_S9clT zokpLeB9*=vzd9cX-~C_@@ks$OB6+<=T!CNDcki8;Il`nZiNk^Z$+RUEinL`tHRPu) z=`Yz$q%AdxyZJ<|pSC2n>mrrD3w3lik+$r5zMrBL0HBl9b%yCW<*4KBruD_O9s^EO_B+tuO$&9W#I!#%yze6DyHpe{vboW9qxjEL19`fecPcR?aRGQ5(UE*(!O-EmObL_CM z{LQf|(4APajyh$dHEfQp@gUXC^%_!7kj$TWDTCP@yVustoPpOfX!6m{gBEQ!$8`I4 zbBz9Usadf(rfJJH&EFi;)v|wk4hn6KX;LP6mcKbhA!ID6dzUW62))g*iGz%}qRlbg zIB`Q|?>=5^j%oU{bkpp<)5PYOroTw^vU$JS%`qQt%;k-H+08Lq#^!P)Hr43tdoec0 z{N_x(BgWayFx9NP)w^ft!^Ck7%=r)@2g4ZW>3 zX_mjOMH1l-M3XM@Mx{u~NJ6l!<;CXM*186qG22>a9Ame&bUobySEf~AwzWo2ZLhlB z%)3;caE|61(K;Y?pNw_oT`D4Ibx(KH>b~zmK=fEeznLjd`0D;95S-+(R6p~UM;@AZ zN|Wbk@~qyzx*vU>MiuI?drsi+t3 z#RP}CUvidF_cWA%It{CP0tD6lAZjS6?lp<^=#6QAmx@N8q#~6bhF?$Jmvr)XsfZED z@ftA-zgFF+Cm3~491iqPs(UIF>VAJ}$XECDm+U6gy(V!t3-0jMJ+WOEsq|#j@znig z9wM%1AUT6tPalF`tM1<%S;}XGh)e!1)m3Ov?@|#pXP2r3Vy`mo{`PmNn)LjpiJaaZ znE>hl?NU8Z?(b54At1v6A%UkeLjNoAcd2@yzLVs}=j`C`Qc*gC$!3@8&?o&}Dp}>` zVg4>vPL=&u`@2+JMtyZpo&x5l_dsvFU8OGQM@)9^0UfKjDb_~Yuj zs8rFHvF_A$n&#n2q+^uRr)RfzifBdOK_Q%g=VkOC8)JpBo|Mli+Kh<1j3#zl{pVli zPnTdSGviUy|8{XAILST)%^cz+ls-O|jDHO78glwZ+)|6irdVcdFC!Z5<9`Xroq*_J z{1(f+(!q#ENxTBhnto*V*wKi_R&mNYG1-Vl#ZyK!ItHrD9d1OUQ*M<$uNcuNHDxpe zchOV~FZ~dDqebJ_SZ0U!jc9ZgO*1a@@|#99w$5oIv+NTi8r^g2?bu{Qqo?2#w}}aF z-$WCBQmp%K=tiuQQr6`tM)rBiV@0YvP5UY=rS9Z39ff6wdVkVs{-Whhj{{MU2;Gh& z!V^x9BMo6^O?cetF<%pgCBD&Bmf@(_>ph^hirQO2;jMr)iLRczR4h$vSx?edu{5nA z%_3~=k9q=9*0J|02wcI*+nE?}Kd_V3U-!KZ6)|8f{s_i^hh7V|AAuj0dGs1T2AmCo zleA?v1|*uwyt%}W0R@y}z(wEtG2n5!nUi#td7bWK+mn&|QSgB_YAt4d8 zk3fUfKEi2-L7sZ-JRQH8H(vIAgs(t$lEXE32d*^ap@}4LPI9y+Cx-Yw!u^`e=-D25 zY~tSn{ZzRh67ESHb@$bc{MFwN39BqQ``1qC7kXF{5gmoB_fmm zf1G`Jpib5I_dd^XIPS%DC|%cep67CTZVwe9(@ip_IjJ<7RWt|yP6;YuanCz0W>-?X}n5r&1~r>*@pSx0@R0 zcVw>K^nzOFe6I7S6ClW)P6!CfolY=Fey2bD(s++BQ~;C+Q8<66$$M<}m7>^^fX#w> zOi_cLYC6$u(?Y7s`UKYm`}aDr6s`eY@C`?(xdvJ)M|pRy0i-k6XoOPCTm!${I?!B$ zL9z}l#+$hYnvYQ;Y)m{{2XZZEX^J?vWY7ZA!wfymTqDt>i5e3q8%2%@ohS@$)`iB< zkK8fg4=D8yBt_Njx=@182)8&pCIBX)GP^G1kjgRPb2}ykET$HYC6CtFG2tGP;RO=> zryUbqaGQtCm~fEMMTDq~9uscTBt!jDTh3A2^2Y>O&XsmdkmYbiQir(fLR?>9MXHCp zF2r!u6CI(YUI)?^HZT1x;7lLktOLy;h|dCPe((@C4ZZXL@Jo-{@JoLb9XBf)ZpAa2 zs^9Lzl1mBT1)Cr?`dowCB;RN7rwo2gzug^@XY{w!#daNNEQ2L=GrJD-HL-jC_bgYp;-L-ve^8!Djs?qbfNsL;jl#g4{QG9t7pS$qbTj!C3vCZcd=~0Z<}* zke>QYUacv%Bw&c(X{LCTp4KsFsMmpD;T-+kmla6oWqlcf%*%>juA20+GDxcVr+yVZ zHanw4_$u+}m$lyn^*YCsXn|k@q=)P1sbAJs$<`a{i8;mBmjtb(6o>no~Tr@)V7Kuw($?&tm*(^u*Sj;#(>oe?_Qo^EM77Ml4MD}2gz_{@r=rO8vpnWwxkmYk62~#%*x7%GE`aoq~)(1t$|Njrpkd= z$S`H`GfwflrpX{>@pBIFkh5fnviNz2eeh*6Kw12v13Y}33{MuX>`#@KcBoACmg`r= zs~lkZA{m-2ew8F;@5`_RF(I^BZ`L86WyVBO634ewEh+lfm0EoG0`K6 zZ?1f2qYN$l= zq61)!-t&S_?;?A2D8;Y$^)JSKD1Z51fFN1DV-ZIi8g2ZZe!Hj|^Vi44kJ|z|KveN3 zPku8lDgpUKF8^~GHF~cjhvo}{ey!+gEL@uuC3KlZqi;252ZGcGi07|K; zEQ_`qj-(XjTN=$u%%oj~ZHJKdvqfTkyteogf8Uu&blFl%{ypc6#7Igq#wiJn?z*YV z2HIlyDpjG;Jrn3(^)4UMiMRawUYv?rtpIWx%?;L})&-a1$NlODW9IV@e*@5!H+E7+ zS+I$IJDARQZBRCOP%>A(qD}G;_fHnzx%>@fkwucK^KaT9k1Do{wLKO)Y}E+J=2#-B zsD-oCewor#qGzf={6ZEeEfXC8D{blp1LmNG`Bz5%@`nPH?4#PWwBl0w?V>tNX-K?> zDBc?1sTMA6sUXP(syd~uWIJ&gHSSa`Tza^so4PR}9;6FTO51KHtrWCq3>9}RjgO^m zM9~rS_vdtCdcz(K5f*HtF?248NNW+PPOrqpSu}{3mKo6WcA;28$HSL4(UO<5 zG?}lPFSbM5+!Rdc>K7G(c(OCMsV-eN%xORz#kJc4M zr5BW-_YS4D;>LT42ud#zMF4(ATO3PABz95{g_TP$t={1^daFuDd%Lgg^zdP>lpqj3c6XsDT@lfW^k$gW|UKT_&?G~EuD$#IT%^e zY$b6!h?7HpQp9(I*hST7_m+H7N*`2ZC5Qh{4j!farYLBQH`S|B`k02)QD4^5CzU{M zq2zn_${=IuvoNI=+K77aY*b>U?62QJudbUC(nl>_?Ld=rZxn*xme-^Nrlnks&+5>P zAf=s-#Q&w8g7pwV;O`k+c_jWXtqk5(;CC5(ei<D_PB(R|R4Sz=uj6Mq<_e$p`YS^(jd+*6K(<*jj*A zvDP7wZLNi${^4BS)76c&Ai@hO8C=6!t0w`xz+u@!IOIZ-weoS@&a&1*WxZ}gthE?G zH97Ne)a37Y$*3yK(gRqq&Qfkr1J{7WqO=tc=n?2Jy#0bf~LE-gkUB^q!YrR-g5 zX)!uE0b9x<)zaeUYH2Y#C5NR^JGrzN^{L9TbDlhWH|p!K_z~;-)cjh~lBZS0-B(5_ zys+{aF0KjlHBM8H0IpwE+*ZP!4BVMjam`5=#+~KjSeI_q4~vU)>Aj53lXd7e_$1Zw z`zyf3H>r+4Kmw>KCs%38x@33Ll<&}+``=ADiR;qSHYLctU^0W3+opVgn^J-&+NN~D z&)TM(LF`^2Wgm8^TqUNa#2_NUswqofl&i$llrGEJwkfNyw4~<3na9+Wmc^gV`u=L0 zvI=gCZAu4s5AzMOO<4t(B0klWRd5&ErgU(uOSfZeQ*s@;Jz$$s0v@+b$pFzk8eT9E zSI4zWt|y<*OZ|2@mX}X>g$8^6>-)Q^iC3<#?6Hw9liN=(X6i4mM|lJF_us(adH}}! zF(YYr!$YoiuvQa1fY&qI3wHP1(%UZUc2UsV?rrGBCFu*p$tP z2W_d?lx<+D)IaQfSWcr&+!)(glM6#s9BHTUEZpwZ}lUx@2gGrb({EbMkyn#*G zy%(EJ*^ZRxISn4|az^t9noZfqUS`Yuiv;RT*>wgflCiOinM9Tun`Ad-FS^QX%66ng z2aHwV2`*<8yVPvTb}A7)eWTfw?Sk8%ZZ>5*#YdAbHk-0t@MnX~rff6{&Ewd#FI-_Z zWxL=n2jp$ameemFVK!wu)TtX)yI`t5& zpI}pV^~V+6+!(r#R9DhP7rt#aW#`L?Hfr3ws(inlpmtv`h*>^5L-s@kUgWTd=(lgp zrfipb=yzsQwpENaN0ypR*)LN?RTqtBYw(M)R~gK9Og+%w*_6!&<98$#b#gXkGkhJa zmWsKXvZW!9-e)#t+urP>f5`VO>e9_@%FZWXq0vu2nN8XG1ZWQ>X8cmKDLbEvU-~E& znoZex1S0z3O|vOG567B{)NAiLo3goLsnK~etJ{(^a8sno274nIm@nSWj19)oD>X{&(hOp*07th znGImZDS~Y~?WSxdKr^Y`V%3hao3brV?lN0-h~1QJ1dH^vukEI6wCulc%C30XZpvmV z?ojErx7tnFvRgcVy4{rR5dPrYhh@POkgvIqHu_*w_Rlo=#B{6VdCGAy!M9!XBRBYV z=Y6E(z4V}qDr`W0J^{SI;%x8@FcBSL1M&{348HyPqY21A#9|gR%O{};$hULA1;r*H z?}AfwslD2i{R~rcxgjc}gKw8>lA-4k>NI))qFww+c|CCpi)KLkQxtKysx{<))$F8vq=9Lv1+t_R?4q z-SC`o^o%Zj%|zS}A%GW*hS=zJ4Q`V>iNRMfcws9OasSYv-mk%(llvU%pVB7cejTxU z{!J|8FdK27X2GfB+=x50@MnS?!M97*t~^vFC%Ba#d;>vl@U0Spa)WOSl2NTzlo6pe zVWai|P$E2ZSd`0eZD0uoTHx`d;`)6zMTa@CisS5u9_5l zV~|wysH;q*9A;;f2>TO{4!+IP6mf2W;6g|bhtN|8-x?$*-Jv#NYnQ@q!hQ|p(JFhS z(HjKt0)W*f>_+Y;Y=(nGZNlyoH=D4>kx zT(k*W+owdkT<#|9zVtzqo3O8-&jo)P)h2Alm`&JU5LRx&9<$wS!tO#tbS&sWPscl> zP1rwalK$SYOwt!5QSHcV!amP(MmKBlP;aoMwwth7zTJe4pFYGoo3I&nF~iIzY-URx z{+^nUU=ucjq88-o@s+V-Jh+UpfVB&!Q4RGb?4u5KHes`HSVN>{Uf^uPX80%+nreT# zvk9BwR|1|c+iN#r8*=q|?AgO^!nQd1dHi9Q-Gpt#DZV;g?IvuClbf&~rBc}^qfOYx zp`}gO&l8+y;9!Gwghz31lhWkxIes(*@O*41p5gm!e8iVhx-G2s*O>waE^ZN za1W$2+$T{vGu-2st0oQi43cX8biWzyVRlA|umy5cQG-^6ye}bJKM|2V zlw7uB)UAcWRk%1dTlDS%xi*$!b*T$1R@(Q>US+cgIqPL*p_+3q>uZ->aW zhHS4yeUhy#S^*P;$2?9i0tN1~bK_Bu3l-h5j+#DH^O-nx{wasXqMfOOxT99 zWwUR@!!-T90M=Ue~l>yo^~>89;|iHVo!@{Vk`*)x*%Wl*?Y*A$8)=$eJ>1<97SV@bY!8aE=@mT`Eu6yH@B z74j*w*{hO0394$vd?CIEufwEw$D?n)ttIKkxpc>I?dy*!6mQWklkBxFPL{nw@H@)aBAbaT{ehXK!|K zQiHOc)%m2Z?6hQ^DW(I#fFkTj<`|6k`?YxV$}NF7ldj##-d2S!dR@zyk?hMdxE4~z zQ6%GB$XFAP22E2kZm&WY?cP>hoIw%)>>X8c;iy2YqLT%(cUHx{KaMV1>PvigC%e@| z3(1l3+e>3&5Wx4k;MDl5YDn;0-9y1ddEfv-32ZwNF*HmrK^!1vzkJ3mibv?y?0avQ(}IdcUg;=mm5Nog z&*%5~q(&qDxlaA`=MjhhHzEA$3kVygX31$m#p7Oh5T+h9EvT65h3)8XObaURR|41P zNC=tv3?f39t74uadOL@Ri(yKs(|c91P{L;tspof^#9{kh!y2McDe4CoCIv{uPK{`4 ziGOinF7YmnsN~rMTWYrp%Qu%SWAFb#;)>s2mCmWwKUJ}g!7f81CMiJ1jTmiyPzK{F zYQ#EF#U$8ggG5))Rk%7Xj_V&SI9W~$D(bm7u5R?)1UW6JI4HJ-dIcRF36n)j&yv%E ziiR;cEs)?FPLb1sibgT?Ax+(+g`5^tq;kM5u8|-2ipH^8w0A~TBW!=CoEB6p^`a@a z%a40Sxl0mF)SS&?y_l1WXHHBDDxUJ9&6=~qC5djO;4Y%3ck%nM;GPf4 zDMH1_d_GoLq@H?Be)=m$n|^j-H~AT_xH9&?Ta8uDVXIt7X2PexV!0PyLVx4aU-6t5 z-QQL5OsG;0Ge!mXSLe@r#Z9qIR;W~R*hKm1ubAfIU{aAff0lGqE1uETMBf+D$!+AP zzv6}15~nMceT zQXOfB&u_(E7bi8iWxM?RR{S2DKHW4T-dYh}dzbwDRxI$A;i|5OT+7FkX-->uu+@qu9=eNR-%g?VIftnAL zpWlk=E;!Y0r2PC=)F2;?yTAPW-W`{p--<#FXYEsWHU`Wv`J+i3#U8weH3W6;BqQ@SLMkiYLI zWV0t@R^k!#`4(kc=_(f-yWeaXkFmk0kodKJU>9cHZ-}#L2{TR|M9FTD`ocN%2L@#p z-ypdj;&HeKkWkpJEB{Qw=pgFu=5UWa1n>fY)w*(dfpfSA!$G3fmFvu^u8+!ppEUM@ zKY;rj%7-A+>&l7y?YitqIl}kpCSy1POmGYo_bw*KzFmQoTs2#SFWFb zRT>l#sdMfkK)!nq+mM$#Iyby1?igxKQTS$mk;zdo{ z(l-6=57CcR@q?P4x2Tpl{bBmCI-V-~Sbabt{0b(KoVTbqCi8AQu$<9% z8vMR`ktFpvHGXC`#wS|p5HnBA1T#0rqqjB5NAVk-a(1pyiVrtYF2?5gbcgeOs@tB^ zNyGW^sP_g%vL$|p)J!-nUp8z;bm_A#LM0%`C}lz(Z9-1*MGN; zD21G~BS%C<@6{0}T}N!?i5(chXb!Pl{s;AzW{EEWBXT+nMX#`@ri7wqv(53t} zalUx>^D3gpB1BK5QSLS!Dyfk$7euXpAVx0RxeYQ~y*!l?@F2A?J8 zx0$6m;EHSI%s8_wf!gYqe7vT9CI|etn)_weIYN9e()lfFewTS8AEyX@rn%MCba`mz zt;C!;rY)E`+)HL#Gla~$Hj#Q+&9gFJ>H4CBQYczYOESB1>RYW?PD?VsI$&wK$R8~~ z-I+ZJ`RV4NC3UCzMrW|d#J!lm(NUYP9^w7Vmi>t_0&vZ^o^;m`Uq6IRB zmN`a&dFV(l{9T61GRHY!74lklj0}}!PH=HDRMxqd++~tEN#S5-b;oam-{kI;%*ifJ z-til|Q-2zLQvR{88pS2dvasK}9j{0v9LMxc<6O^nH@}hASKo3}y2v+u}3I zw#bY~n!yGi$wxNQStH3C{E}Mq4aX#-@r?2oWlpe&#|0SwQyt6g~ynjbh3{!KdaBxQ;pZCRoAm>gNHhtWcWs0Qybxyg?%dP$LVt#&Mvu#}^g z)>C^-dRCLZFoUDJ<5ZcbvPkuuM>nz2oIH7+wgRi4S~f!+P(4h;VGPXj_Ik97 zC)1`Rf@x2xCK4CXB%>qERx;fw>z4H6(f#PkE@#HXIKpRo0U0zQa#6YXZy}!8Npp}B zE;Ya+NaEqWL*;}-LM%k5K9y&!6<{j30x6ScNC~7s`7d;-Y36J*fh@V?15fOrk{Xth zOp#bh`FG&X46dHQ)ux-E+mNCnOgN9ks5_8mxvgS!vPr=KF}{W>MVSX)Ndqcu?WHss zhCXl5M)433Y_cXg>QoEHQP4CKkCzn8Rm)kEC{ZYTKS>YhO6NN;Yry>cAt)_>)>S|K z#RT&&B;$w>-2CBB#={BJ5fR+YREtZ7gEYen5E8w0v6@|_;wuTDWJjIpI=0p0iLERS znY8tSslWe4ZXL*!$KP_O&)cQI&Eil)QKzmyt0vFqGY9K3(f>qvA?bu(m?^-`z3a=! zPMEI47P-^)!@1B!$C>GRJC+Wxnyx=J*qN>~93<)`xOGNNJzbwfCZXIP;BKWqMF=uI zUB}y_w}G5UgPWSJKWlkbGtY5Er>Ekt(voRDAseN;5 z+UYtg4>fb9>tvrgSF1=mdKX91(Y_o>-%CA1G@Lz;p3&`FOeB360leTklo9={!EKUL z7m1e(rZy`XzDYLQ{c|Y!x${75Bl4jJU^4zJ^xM?l8Ko}`n?vMdTWn!@;tQg z=YyPHiMs}>NV@jS{`0b65adSE&w`-bjZ+MgA?p2~s{r)o1Zp1uMO#|vX(H)c6~&eW z3=#Ba3gdOXk|6yCc2JRYSQuT==;ub#fpjA27ebJUq~n*XCPmU2B-N}w-9*x1c1DTt z60Ig3F*06L#JL56t60s^^wg2`R>@8@Okm3g6yYr&XP<7ieBj;kpMes1^FDeCDugk3@3k!}ozZ->3y7zhPZ+@v29+ zZ8n|nD*}5#4GiT`qfZsMP0}YiFR0DnuZ}UD?|KGH>e0PT=X=PZo_VL~e8t4>`Hfh} zb9b3*4;ou=>d2W+=Yw2719EEI0T<|9dsLO2#?9Zxfx6~)zV~6!+|I`!*{WCnZaN=o z9{?r7kLam8-&dMqO9F-nb}+>jdUC6x^CgxXuk?e3bM&*FPhQIaf?WN6AxU}qF-Yon zCavSEU4^iB0F(&#(o^fVOH*t~!1RHD&BFbTehrc@KcdDVd;_^FVBLVb!rTYZ6^_bHa-fJvwOQ@#JY?meX6`44uF}-wG@3f6E9So{Ajs{CS5i57U6Dbu zD<1!c>5Awb0Z<~mhMu}BF4GiS66h$wWTu!zPxGoI>vU1$GIZK^TrIDhxY#(vZBr!tiRmfGk9lh^TuRo5lvG!D>8#;Zw5>1ZLgUv z&+^N?hlQ+MV-6Yng8-h-;8fX5&LLya!v6>4GIrouHZ=X7=?8@ws_eiq+7$) zct$hm(^!qxDU*jKZzq5kv}MnJy#}{QKEvRS48Gi2yaTP>Y3ipmxO4Js221KW*5ciX z-Sd01kkQuSCt7f7`wGY6(850zC2CCB3V?;r?r-@ya~<$kUhBuzco zp4Eoh2SCwUG(Gh@c(10|l7JzCx=c}vp7tHwUZLJWSU5*N_Z7!C89jB6XqDVnL(Y}-f_2$_Q_WmyHi`Am zg%VhA7DZSrS92x3c1m-lOK5dl&6Pf{VdqNB#}Xv-=Om&@w*y7BUq#Wa#Bvt?UeYR= z?M@10HXCP_zd2n`E)oqhw3H(nuE4Vh4lH}MKUrV(8}dXSLM$UQ#dxA!cF}wIVypt!hw4$@G|Br; z!QSwBq7!9HWAf0*@`GhyYv2O12>B!QuRM8`2PO(^0gxZqS__E?Yyrsz-n!EvpFN1pupQ z%ghs%Re5>X8fqC8` zIz4TMg17V${e2g{tYGo&zfV*0a(9DQ_B+9N-nl?4Tm~H#*VpYpAsg>f5Cu!A;6b zLoI15GcOI{5AMtLsR{|7wzYW$msiW+kAkbJ1q&fo{u(QP`46*ho78zv1>>qcMF1w0 zs7w;PS1Vrf?lMhj=QSdIi=UMps^pF5)Xu6~X}->pzH6UXOHqjQtsAQc2BKasj#VIHIj*0Z$?r=`0y6H$?+jmW*Z;s`ZVKqehSTp$(kv{zNQ57HM zIFY_wguejT5N%W?(#MpHw~;=EEwK_2=`%1X%trbcvD6YH(q~|b*hKn(5YgE`7Vti8 ziu65807tlp_HI`=FX7-=esu9+^0lW(pVRVXa~ButNMFyVXbQlkbENNM6c@fl2G)^2 zbYUIodtz@L6X|1~am4LIga|(-9v$ghv7}H(`uH=Wf-VPpHtvxY=g!`rz3s! zVv25J!lC;Tbg8pncOrdISfs8^%Do^Q>Ek-U_#$;uh1?6mkv&%!YOi>7e)H45FZpG+Hj}b#7&XD zJe(r9@Fo-KoAk743uX@IlG${m@2`yod{rh#`nbO6pdz}sncRRxkv_M+4>T~5J`48Q zbkV{wd67OIT2dWG$=x^{>EjY)q;K^O6X|P0DNm}mu&8h$X{aN8m)#)uBvGUYZI5`w$=DPx#Y(!6XIU82cR1ZyCC_aY7VaL_4Cl#v0Q% zP11%d>CY!}vLk}eCn+6qSV`sB(3M4j2U;Le5T4x}k>_BGEYZ($&A zNa3!MD#=^&l>LT))1i>GNhkXT?e>i=gev@VgZk-L11x&=82MGtzUu+t1%(X0Vof2> zrnB#R_!da8)IPfX4>{A$Zgg>&YKzpyK5}N3{Y)2gAmmXc9yZhM#ZU47drCyZ90Puox247dID$zvkCkB`+p=vVq zS5=c{RS38`(U{dr!oe;9dllU9scEOG`W~q@Iuu1yeS7|{90@(|vyMb-)~-U)o{vS_5;fR&geaQ*_Cs)y;Xio6|j0eaH=g>n$moJgiAPW8uB!CxKoDKd1 zCZgbB6a05bW$^#eXH4+_MpD8HhM@?&4jeL~rZV_{`-Ae6 zn?&%R;iw@z;b&{g;QzTWtq%UTqlQ56-zWW4@W1ZaI`|J{FbK_CIYoFX_|1Cm)a`2PWPqu@X2P4Itmtt!F)epDEH zc+iJEJV4mPd5uA_TV%{%?8ZUxNS4 zupL68Pev(+D;58a0A9edqa~vixGWBtUa*s?Ywt6`|KA9BL@))R#gIPaOQ` zGSUA;_&Vu?UMPeAdz-7^KWve^q;VM+`rHX-B)Wp71FS}(vpP8=5yL^EUV;~En2~5a znZygO25u_-DMFCxkqB>(9*K@BHY3q8%d?VsrV^bViSD4k^+?qH1TzxlDX2!G2an8K z(tsi&wY10?iCB54nKKg6NPWq5`5^?fuMPi_xSj|FazgM8Iu6&&Up3mS^!8_{3#?_V3 z!e0+^TJ*TN6MbZpUnNRV12px&2G@af7L4x(vsp04ue=3g2FV5EZg-dv0;&}-Z+JiP z=mq13vrW(jH4Gks^zZ?C+6CiFC(__g!F4FY!S#Z6X2BSJ*WU^y@Mei3v>5sk1=m5Y zg6k#JBx=F<<@R>LnE6-&Gt=@*@2x7hj*i1?R~Ub}ao<@*@*7^dnug=(b(+MhXhjzS zctINsmCrg2ZO z;MDksoW_L~ejkui;A%p86$kneQNy^iYK~lfD@2ftw zIRSeIK#4F-Pp#jbw0Vrf?^_ZueUN2}ru5YM(Lu9Ms`nh<814#~a&TAJ{~Ef&J!|M0 zolhZ6)fGk%zzaTvtO&7U2DeGx%HU5J+$S_$p)M`SY3g)c^Pab1u%v$VbJG>RB6iRJ zmW2%8X1c;p7Mwan`OHbY=g`964RRW?{yI@jE-`z`9nvST#7BCWAswGWT5|? z_jHDIhJ!>6>6^!xA^j9GiWl4f#&cnx5M+8tzm33pNbh;G8PadGJTsYR7SZV;eJ=g2 zhxAds%#fa^pc>MDsK^`Ap@>L{>zpB-m4}+SLwb4gvB9bqQ#?jb-4)A|?;fqjY4pGx{p_pa9RZ{> zPOpF7e-`|bJWpKSKgA>Dy#rF|AIe!d(UxPa*i)q2u3ncX}YjGJ|Kc1<_ zWR1m7A%N#IIJLvIIOO`LgPbfr>u_ap)ZjlY4y0r8gTZVpj$e5eXOOh`-`bvD64eTr zH-!JKE&kCmV{z0lXbtJ%q4d;!yj5~Qxx8Rk$6(6l9b@JqeTc~)z)H|xq6mJhnv3Xg z00pmSkQc4yB1@0Aa}nla35dUlqI>E2<8d;0{UosrI9>*?Z#kL9atdB!7=$y%9x(^6 zw}Y?YV49kUA~;|wcnw1KwGh0X`Wv_x8c)gwuOIO$2YI0kUN3nOl~{x77r}ky;PnGV zh;j0|_M*y=515FjZ;H;6Q}k> zo%!EUocilR3QV6{gC6hIq&RgEezq<^oO;Q5R1d_Nu?B?R65-FVmc4$gW+@@(uF%IIQ`jo6tQkjle-oZC}RCe$4fU7@PpS0 z{lOX{Tz3&Y{x{-4nm_jKp$<-Zy=_b$oHXQpSwP7}->Nv?O8SG>uNr-)yhGjsSCT5=cbU_D#9kLVuPBeok?AaY>@PN120@9L}ii&F0`F7u@c<0(lHjuf$@Ktt@&gOc1vEUdAAC zaMGDSE4pJHHGN3(nK*UrT<72<)1Z`{OmR}2mXPi57BGixy!{)68&pN8B$&O*9Gqm0 z!=;MotJUV0;rluox0gM zI7#-whkBTUlY)12oBE4b_LF2neQ?q<^tV1Zsa|(;aFU}dTaOu|6Mikw2PYk1g|fm? zk5|mWNe)ixcg#!Dh2?{jxRU7KBJ#VcSVNcOTTVAU^Jles-!1ux18(|Hfj&6NQBRhh zpoK4-tdQ-UM3J(?`w};8SAjk_$@Y4M>-SfIJ~(NO?O2kp^WO?LBKaoc(76@gQ@<4G zgOipJRCP$^3-LYB2Pf6E2PZjnOS$%k?kUg*CpkD-cEMhS8=riZgKHsWd_Xev!AaY-jN7ZwMF-e}lk#OmZ7(wiCso1i9GiD=5)Vz0 zmw#{)gHv;^bPi799?G%e)Vvzb!AT5f?NjHqa}G|jaGD>qKeWC)4g2*E)U=>%hZCka zi+<#uhP~`j>Q&3>A)-t>Xi7K_T`@IyWnSNQmIbEUeDBAZive0)37^{r@|yd{dcXvqc&I1 zI}KYF-|v2N8n!Hl1*WE+SyN^zUhb><0xMF#{GvR!Yc(A8q_vL3ox9boC>L!}7H;r` zx)r6vHlnb%qWt^_aoAf?@YCM|SO^YGfeN>J5+A2<9pjsSh#o%tOF7dj{7T_*{*l2; zA@)`ji};77LosZNDg4}%MAdV+L8L^OTTvjwxfO*a2B@$UfLl=vO!7uYTqJu-VXK&I zW<#Ku+G?f`c%sF(!{AmFrUT5a2W~}S#6h-H+=^mgs?_rbsZx8mr7}~r`3X6JDeUdy zxb)QAaMsWb8+h zB^9Qf)znWhc`5wHi)Lw(%VI^F3};x2NH9ymttjP7&dkVgXbtth)R$=KNSPMHT039f%F{N9VM*Vmt16LX|QyEJ%$%NdQbx1uiU3+^*e&N&P3R55Vb5G~uu z$z|bPu8`E;R&t~)yjyoB$P%dr=R3Eeu>GRZ`nHq%VlRE9o6=|UuqX8pc=5Ou<#SCp zH-_#b)s=Kn*LTdVDETs?Cp2zeRlZFpnp;sUAKkfglDQSd7A2w&_4Ox998E>k^?P$G zic6hrWNt-iNqtsz(P)$gzZh%FV76nbWPrN;+P*5`2;L98oN^-7FxK?c^{+%w1*NCJ!Ni1$rr;fee{sM6(x^A zL}UJEZbiw%aXBLOs6K=|PL3N_EcKOpD+=2{cBV^DaBf90aH(bLKKE7>Mq;=W(S>dD zZbf1Hr|<1%Z$;r!(<_`?QJDXv&HRnnCKrEjE6RaK*;`Re`6B&*b1MqVDjPqHreicw zEo>Tx>O6?auA9EgxfR8cG5Az_D~bWjs-^q&r|Ai#wT#Pwn$3~!agx0iC6A@dZ(wdk zf!QS+SEy{Fy%hz0Me5e+Q`EH&y?$7=FWlj!TNT<{QCRv>FlSlm;pSEph?9bW@>zQN z6X#YGW&@aUieTK&_Er=oKr^YWW%Ha{Q7lewEqh%bJKtFuL6+BeN1<5VpHvf=U>_pA@MU`|3ff<_#WLqs6xl7>ondc9aR@KiS6!^%8i>MisuXSknx!-euvAXB zqBMM12IorN{>+&NR{uPI9#{jjg4+0yL__SYDD?rfk*vh zZbd0(F^!m|Dc$@#^6h#ed8WUZbfe?n8Qjm_isFJd(7CN@9++VvTyBWU=y_n{MP?q@ z!j^MXml}EVKv~Y)^UOR@mcs&5*SWW%aD9Olsr%epQ5cSTVm*1>UK}|_x1wkZn_E%t z1!sDNb1TYxf^cmSEE~>ELkVjrf#ZIt4X>%cPt774j@nAkD57AEiu-jVfEVn5*ywT% zZj&6!;2#)#>fvTh{d#07`_<(32O_DFpnS zrr45zA%fSK;stuzxYoHkVGS0}(a()*0qLyyzXd^N%^$y9H7TyeAgN~4YfO{{W@nTL z-zOfu=6|E6h;s`BTOd9Bh@N`Qzd`byIVyarT?)H5?+92rYHX8yI-y|#fK~W(vU@8E z!$G3Lr_1fFC^NYIy8w3|{V76_>F_B!HET>sKFjQ_C~GXwyUcSe(dqE%N%S|@fs%Y) zJ=ug$^AuF!(>eLKqCgRm`pUf(g_Vbzx#3gVH1Vst6-C>pM7vz>tti8{>042z(dPm+ zD^$0lFvi@9vX8LxR+RIfl@ttc!U))1+N7dp41F#Ky2np*ANio)>k0Z+f_+=^nz)#q_%4|^+$ z#mUd(?Yr%*C`O#(TkhP7VsXqDmeSV{y{nLJMKKO7-HOtj;5-wjTT$NB(}GiRD@rqR z%(06HeS>%Lygk4~&d?+LzElw(wh=|>Wh!z8aE z^pOU)N%m#%Yz7Z&Vut%q9O|z$xO4JPhq_U@IYVI{v3vf5EaY{2E6Sr5oa)`sIYR+j z_)mbGK6!1%s^K10$r(=bhkFp@4) z`)lW$5HDIFm<;LRBzo%MzT?yFDau&813k{T4RJks)OmOff{y2wQP2=m3cYw|rWD<& z*Nb#5b+}UU(qzz^AiQFRKDOa7toqTE0*hDN$FNYweXQv>=woZ~j8-l-ee6yGc)@gt zjZRr&!t~EG_zng?U2OW;krYwX)V&%gaOY%y221MRFPV)I_Y=G4KfpqMAn;9e(pIup z@(~M8l|AEZjDQyY;~*y+96*PeR!0szs*=-&`F#uoxqYl31m*TI2Fb=-RLg9YLG1&e zXcG}Vbswv&ZTc7t5nRL+gXn4d*z{g%8v!hwqo3QyfOPuU6%b_l7=F2GQXgZGRP*us zOdo^U870E2iAVRb-g8YKLkk2qLV7rnp1O~fCoj;6&WPkd&4vqzRFvJ6m*~71x_}0@ zKTan)1CXESe5g)zHWGhliMzbqMCa|0xKlr{z58sH=nO_qbjBa~iOvrlfxb_P&IqVM zVLJy(FDCV(uWf!pQv!Gaz-kV(shhKfjNu?rbD-OgH(SW=pn$j+WPzJce~J)fdJa^R z{$>-?9O%?xW((OHmghs}X+v~+4)nJ+I?aJ*+Wdq(1=SqryqE3<;_FosozbNKo#@;kvFBKoliYc?Z2OXP zepP!J%J!(7wS8+V+(6_|uQmhs9}%;*B`AJb1x7Ac@XzYjTo5A%Leip{mYFUVMbf zN&cKkBBCIPcqtaA z4>PO|cq9xt$p$8cNd!(GX2gM(7&*xXrie{WG7!{M_p7|)f8r&?=m;0lwtE%MOE@@| zA02k6d_yTG*=hN*Z+e@Y z$?Kb$oMeaYIp`^gTM)6%NnZYE9i5Zx6xfw*@Ep}g=Olmsx1yVvaOir0E>*VH$w`L7 zBGonFhdbcv9?D5}S}B?}L1h^~k+4;v8T4$GWxO;8{MJN8 zy)1#+>X*D|j-q}h2YlTPCMVg-_Q5EkWVy*n&ci8!y4RbW(ZNbc8D>ARnNj~## zxle&}lDWR4C(A&QQk}39$$rdMF((9VooMgtq%ql1O+z)I{vc<`qD3?F zoMZ!5YV0VtIms3$)!22T%}Hh)4-94d?CHa1Fu-J>QEQqEASW5KC(cR6Cm%B<&Pl$2 z#vPfHY<473PV$dB`*?k<13vSe`3rx~btWgd8=xmJ^ynrgC;2%NCTYVy^m)@c$){dx za*{u`6lV~H&Pncki^)koLzm~D!{P_rWO9-%Y9LTHCmHHVa+{OPFiB@}lDQh9&VqH6 zlRR%4a*{`cG%ZI?vat>ZV$MmfvM*Al^8)VVBoAX%OinU>`Xc~~L@$$*41gDmWbmIf zN5ly~CMOwSseQEVx4fKW#$i@0Qj0dL?MTQ;=3>S{9#vvyJye2nlB-t2?CI3CQI!DP z$w{67Nj4`LKm8j3iyG`PImrNc!OaXF_W~Vdj7sR7WPrI6swQ{u&dW)*1YDiyx50Ti z$xOfw05^QfY)tvvEUe26f z!VNNNc!insPoYVP7c2zs4*HYU7U@qt=SNS}bN-vBnmPYVmgf!Td5q}voFBDfM~mkC z?N2r9o_PwYIe(&8-kcwbh*an6ojE@%4>fbvJW|8qSt22X%OWkzfJ%zusEBO z448;wi%d?kLn?zj3!gSQ$={O_Ua%fT$eiSD4b;}2_SJ&l&UBJa*{WIN#`W91jqj^gH6QpA?~c z_=uZ*0XmR;By~irtL7X?&J4XFBpN?PIb5mui3Fh278!i?eb_`05sf&}j6|Oj zzzYCYBT7_nhFUBxVi%|m4m;uiZygLO`FDT9ZfVip+xA$CnYsE=7-Oj9Fyfuz3R z5tFMZGq0MlkV_VuT*c;ScAvqik&D!eja)@&;kN`itxsHiq*}m34bas8nv)Eqvw-&x zY-JYk@GEZtk3n()Z_jMAfQM=Y%o`@Cc)fu4+nr_s4>b&GLA5ZTr(VEom25IuMl+xY zM>ERXm}mz2uHT)=eY{zs2rY(wL^;VISJ8|o2&$qP>9#fxi1}CoGt*vyjo+%AWON)} zX2ST(jXU^nlHV{vt18u_>FZ46en?<1xEpFmi{DV-HpzVqzMsKww>6DBhS)Xr_eYq< zy_3O``k)!6aUUUe&wreS96i%C?lKEb?Z3@wTxj7h2RSuvvy0T~F{+Z&xcRHcAjn-k z9t1(TtH%tItvbm!tH-E)0F(&Nrzf{61*FGUGpoliL~sRDTtrW9RnAGCd5Y2x7S7Sn zt{%&rWDw-)H<2Xe>Bk_c-;57cpW2*&y#t`=l5~1%{hryVD7GYE`d~U!Or@vRuR*f= z^XfgvH-@_crX1WAZliCSXm}{Csfp-{1*R(q0#If-FS}f_&~$||26tv~|02^B7CF@Y z>X@!Td(B9Qq@K0ZbcJJx-SbaiArCJzU7?Q!r|y2j=?c)oKLg}6WZiYT3aVrFlslwv zN6n*d$Cx1ju(6f#$EKM2tlTY^j`_AhxCPq zn8{@WGNj^Z3Y&(%6P+H?!hV(oI)sTME!FfYE6cMQxn>dq8Rvv2R4(a8| zYlf<>h^Efziutb!2y(k(br?GLRbi0qiq}*(uL^oc0F(%8(o=WED+BYYprZu!nIfd8 z?uzBf+q$W78a*&aKl`e9M*!)J(`g7Y<1~J`YEqzuK~l~6Q_VPyZpkQ$2oMjeNjb?k z-(tpT^w8iiNDs60WHmV_xpw{hFC!L&oiF43IB6K|{?WWK!{%W)90^&`@3a=EviPSk z_;LmhKHI!8#k6j%sfV9q-k6RImeiH2%^M@Xj1ySM$TjATxq$$l&)`(Emz_5TTKG4E zoCePqn=6Z>2LEYsARUXJ17>4!{K~U9gQUejS!67ZY6Z+2!u!=0|KVX{anvvv2I=8I zdRmL0Q=FfZjHPk5xXekeOKbTeYC`j1H5ZXN$qOMXsvz~1#br+N!wkM>fU)>gVkd`@ z!Se?ii$BI-Nqx$z#^N$3`6;HJyw+I!IRbb-gHwmDbSw_J{tA$j#j72vERGudr^SJE zEPfl9jm7aR&*BV{7Vqr+ zLJPM`Cvr~m`5zOo|GR{4vVjPjTtSau404i_)l^2zE%(YvSIPJyx)kdS3Oe6khZ@Fa z#Eg5AtZOr3@YA0FSO^ZxTXQmE7=L7S5)r;b*+b|+ITl@>r9-hQ88Nv; zN`%RX0aj^FbDn^SXIU6BVhl|3M!oK<#rac|5i^%49RepKhM7Lg&4@8Dw;srdVZ=gP zDl%dWOqKfNbX95(w^U||y00)9F^)!Ddg{doe5aVc)QTa zh++Fh6Q7ccdxiJK-Y(Eh=`(q_gn9_RA;^eXt?A~*(0!!3k}j(Gfys!;ml2()ar3J3 z{Y88Fe%j-U!Uay*B09RS$%wH<(eZ~nRqD%<9O^@VHW@K4^^Ua3h*@D?R1sy%6!^v1 zDh9J1Q%9Xzn{GI!J@&|mVT18Il8V|Y_<9Xri(Z#1`6w=E0XuMofM=@||7TT*fgA|H&6ahc}O` z$$8#|BA(9-P3fxXO=<%wGGe%gq&}+~h^}-odtreB$yQHI>qWK!99NE;PA0WXZM;$L zCojakhK$7EB%&_u@-kxB{^@!>ZAJ{2n*Oj+ZE+#p_gL6CF8K%6;%@|fY%ujeMojCY zZAOeKU!>oGgxp zh>VyA>f4MMF7$seXW6QjwMBKC--(Pu3JVBL*$YPHf&oq(6SeX2dX+ zH2VJO3DJET$-Fo&zccAu&a@dZ4&l<@ZAOd*(|W+t?a0@l4Q6_lVuMYqpFsEfteaU6 zm`w8pF92Ar2XvY4tOqb0Bx*h2@CLQ@67OD`#(2T&V2okv6M{^y2fRyQo_5m)v)Cz$ zXK4IjB2+wWnP(%>>Ggok^fyn$DcIDsyIBv&Q&6o3d{&;f9sor|Dk`PkM^jwBBA%6p znz`!%4HDgX7T41=_A#?Kca!})q+#J1F*uGBz-^QqCXkWzDGnB8R0`ZG?xakJ~m zZ3cyRDL#nPe1jEko{M9?@L?k3X&!B|H*;j#Wd9t&`QuKT><^`S@<>A;Wy%%Q(|d9SXOd-;TfG;p=!tD_$~d0&@u91r4d9 zBC7SWSrd4H!D$9>&YCrW&NNNb)Q2=TYXSopEUEWLCZ{S(?4ExZ3u)KPT)WoBf>Zkn zoSZ6X;dcNzd3g(UP8F(>vnG(gE(e0#b-C>@e(t&)gXChsKzm^-Y99b4!tdzGqY^D) zKdvdZBw&c(cc$1$PacD?gq>`lbE;tB9R1vNIUt=ii#RH0)-3SLRg>1`7$ntPH`c6K z!0e2ovptE2)ueT~#^cPI1zI2oAw8@~PgaxG3{K74PFYd z-l|1>z|x^u6>l|{NQp4sDzJ{X%EX^p7`#;jle|%CuJKm?BFi}hjwN2IkfS z-YO%$v8BRWH854`4Ks|l>Xgb%QNNdrx9Z@y^wfhr9dDI|!qWa(2f^G&msxN1kQW_q z)u<|>8`TL`g%`)x6Q>vKgQC&j_Zn~YF_I+}rgPJqSZ}raeTw9=*gH(ZoS`VU-s*c# z8E@5*64hU(z@uHxsLch&TTK_+GLs}wd#l%IlCiOFOd`vyK_uE+tvkVZtB#bYp9W8G zIir)+fmh_MI+ciaT5r__&pgw3t4{IJ`jN(4b-_=cZ@g7BiZ<=2@y1(q!E1)(d8@J^ z(jASr>QJXfwROBz)9#cwINb480T)q2wH1ZD)oU7Pv-%Jw!ZWFd@CS{&)$=sn+!(r# zR9DhPkAG;q)qEMzE{&U4mG8;ZjJIm}M6^$X7db2buz1c_qkndYG zrK9my^9fjJ)OLmOR`Uta9!gBnE5=*Rr{b4B`m}}dR`Uqx`18w*x0;7zO+~8wW5-+N zilv^f=Xk4Z1MVHED~@rzRRfn=rk#Z_> zQ7L~T=wqY3)pS?ut(x*hdet23t+K4L+b=ZUDpcn|Om^M$-Pc-g)sb=j@zz^4U|F^F zQG=|vYH%Xm=UD5l8n9$3^UIC53bV`cohwv!`dP+XMPHG+{mFG5O0S>xRu3q)-YQEk zLO(1!@^Is=LYxvzD4(UL5B=MEtCEeV7^euD*0tU$6QG&Y9QfEl)?2kWId{IIx%F0! zV396-%6hA4**r&8dR*!ER#|VAsklR>|C(XFRoN|Oon^gMhj7^+)?2k;n$SMC8j&IL zR`o2!daE%W?T+nXywz$1pgVP-q&!i(+6>2AWjIKbxB8>?Rv(~g44roj+>`XD2tlU3 z)dT5oo^X-3y3%^9A6cHSn5Ts3w6|JLe`{}bQV-*;<|(MW)#lCeyj3VdSN6ExDk~2) z^S#x@Jc}c5RokaT&*EHf^;&wzq_;YcdZ6pAGRAnT-x5}OtAG7yywxeBPAs?;O4$h? zd8;SCoAcr7g%rA;^Z55;DOd#HR2Rs$D!6+wK(am{z#>2Z`I6^$y@!C;QVnX zZ*_|vY1msmlzIsQm*^YptyWGj-YR;8e=xE7u#G4}FH_#Cp5BwUdK6hkd8=34YQ0tF zV+oQOZ-w+$>D}E+rLr@Me$UP*1hO;wbYm*2;i)vc6wym7jWb$K0J;c{$VF7=72}Nd zWbkkXZ);(k(e)1X5r-IO^e2b9S=uq=GfIS~5D%+K z&gf)K5l^B8g0mq#Je{7#8Lj&}`Jvp>x>??jKo@J6hHm$fQ8_w;*2u>DsmS@Sa8_CIHLwHg;;0QB2HxKP^^kGnoFca z7-tk%#~EefeijC2)W9Tf^o|Xk4kAj2z;Q;I>6=_<)WF<&z!_!4`Lx}jzPA|9uibm&H zXS72zfWacdn+~_m=wq7Xve-FH!kpnWBGIAKHr5$+q(s+g@MxDant8r)Mjv;|oJj(; zGy0__85?`oDf3Pu(az}T@x~c-q(rZ3@C27L`p1S&ok~RaTW8b-cec)`Q+zbeI-@Rl zuysb!DB85IUTd6D7d$%O8I=vO!G=y9>QvfwMoqhm)Ku3Qxpy?Rt zk{s$@))}>miD-|GkuHx-G%qUcrL@lIjSOZxrap2*r?UU!9Z5aohE5qi6+J!mi0h0> zLvFI6Q`?(;^bh&IMWxmm%_m@?(Hk~&noofCP-1RdX`In~Dt_ssG1eK)BcK#e>x|~% zSW}U@<|D@$<%*@wcb!qT0r!qn+I2<^Txyvb=sKf}#NZ^N&H15Iwtsq^6FTKm(=!}r zl=<(=@;Bm8>x{nXgicNQB7MH&jIykO6?auAA=UIHQh?q~nYlu&i48M<;Y@ za3a0m37s0SWGP!>L#Hsi9N)P@W&3UD6n#bNHigcp7U6Ds{j@VW^C0Vtvh?XNXW4VD zj57*xQZP_HOHaS$gie_aV8$teC82djnE=hCrnv78w9cr-$*J)ZS?i1%!6JRfQtOPO zW&hn7y~1%unTk79`hLe5mEEGXRF0)Mz4YM9#yx_=p+Jo z0l>-`eaQ`-G8`nz8C_(Z(Uvsd@q)>~RbuKBf=oN3Gw5%gaFH{5rFBM!Se}v0Gn?qN zGdhp{<|!D3PCHp=G*3b0jDFKJ&l!axA~nNxMp=2NneU8V!m~JXMzwuP^eoPGMhoa2 zlg?<1mbuO-V~jI;Ibo$U+RHkl32OCN5YW?^@R2jRK$GZ5nekQ_XLLRFO?F1n@7WoJKz2sEw4$OKet~Bc zv(D&K1fVoE^#ABQ4Q`YCfWcogxZFCU{b&}bsjt)E&dG5Mmeen%j5GQ(v3vd=7V?LU zjQ(N4sry`K6k7QIfSjDstF$wUs^mC(`OYW^a-GpfAt=`wWsvmp(mRYZirNQ2iSP+} z@}NV`=#`pcO9F-nUS^7?>B&P3M@BnoXA~CB(a&{8fpnbFbr58nQT%e%BxjUCQq6O& zGtMZ?&L|OXARbneoY7Y`MVwn8*aYd}d-P;A5gDDfkNnW{f1^ixIHT9nqt3qP;fx-0 zu)165ZPJiW7+8CT+$dc2Uhk4s9c3?Wio1ojlQw*}&?lWdvFcH}2xCcHUYqkCZSlJ5 zc~ZjOErg$bqt?{nuf<O3oqUYBTPVLAW{gg|tWe)AG|~!X zg`)wlo4bV^oYe3BlsplQ?-t@pqJN9%o^IxDp@W@n`uQ*BZlSgg__~RO`feddJz08} zNeb6HY5R>YaT6~o)OQQnUaxSAt}WDe3vDM$sE#H1E*h_JBa+`S4xL-^m0nz^?-qKW zpe|pC?}5Hs=$7wlNxE@KhwdY;{lL+M`fecyC(CX`H@d!6KyT3a$i_e7dOO7jw7JcPxWzA!YnZGW6X-tF(;UllgSf-CtH0XHZT+_KvE!=SG>kg{tsP zxH|7{As(8dyGP37Rjb?z489tx~TH7=B=Ze{0DhCIVr`_xzM<&KN& zf*d%xf&QN~fkjLb;}YgK)(sr+EINJ1z9uF)lmK1;uyO+z^mSsA3P~v{?=~b^h8a`Gc-QJ@?6P0V~I|?f!EXD+70~iR1=fT zQ&72q&*mT30!2h>`0q|eEh`T-g{ZT49ulBhHdp5t{?k<&rX#)qEuf>!UWhkc6|XG{P9%grzp&*g^h2LtxUdiX!1;xp z`>9hg*2ceCPKP(`qK632=qu+>IKS|WGZn=faZIadg9}Ka>K)Dbg&x0nk`t=x^9!?` z%=v{rlSs~AhUJ}K$ehuE6dD-RmyXbQKQ23*q<-KVbADlwQw}Vl&o5m0tvSE&0H>Uz z-&2PZZjMI|=Xk2yp3|wE`SED*`{w+@CYDnk7Krl;Su^<)GdKM7Q57HMIOiAUBK$*u z4beuJJ?5NW$drtiVlkg%SUW2b=NB576lTvaWJIMU#`%Q?rijh?g+P$o^^-Zj@MvOm zgp266ug&>|4vytVV_M2t5S?G>w0zlNb!&=#bemtMe&U}0$JcehM^!ZOebIgh17&;%#k#~9(w%H+`o|X z97Jvxi4gvM$fNIH*fn>Ic#Y&2&Q^ZtnKS18g@zmv*niI0zi>Q1g)FqmXN~;}(`r&1 zHfjFJVAl69483dYUufYQj4UoPR`{obS>M0#u-&ikUuaSID*M0>K7IefZBE5E)?wl6 zOMJoh`{aNm>0Jy+$S4sU=d$cy$aa$RMX*Il%l?HXJ}?7sOKSf@ODzR_6XjSn=|hKE z6cK3jmKH+h#OihD~Ybg$`htd_LTBE&@*(Jw4A_AfN`GEFfQ zoM!A_c%qh37o6EY8*bD0FSMPK-#PRCgaKI#E|H4SV zz`gVGX`EEZ`31|M-b|X~UjiBW{)L75$R~4B$t--KCr_fqP;~oAsZMDgn-D5{%iO<^ zt>&&H^w|Y-|3U+;rk*Z@<&;%YV6=0iTNaD%-XnhT*yQumLD zZTd_GE>7Ura>@-Q)v;;JKr|^KSZKH^FKyGu7JWjhQQmg{s&St_yfMdp+t|9V%yHii zAT&3j)wu6MYsG^>N?87RIh~7 z+w`5NugPutPGA&Qq7#O*FWcciN3EaKHhrfdl*Y~RIU8u^HhtoGEn=I#pFf2cuHy&C zLL4);>AM4j<~C{OHhqM{Mz?E?ZTc*%a+|(cpBUTp`B}{G_*IqgWg(k9fipR3V?C+_ zq6z;4*vS6JHhlqvQmSqG9&>iq=%-@n+w}Pm@S?Wqv!UZuQfe;E8L>?t3lB6}X>8Lc zb+W+Vze_CJ^l?e$HhqDEY6p$(QOW~ULfWR!6DPOnyFsqix9J;zilA-!G}x!M>6`tM zO$-M;sXh_izf$$4(_gd z5%r8cnKqbtKIc67z^C^lA*A)59zz;ZZB-3U>br}6(x)C|p4Yh%N zwisQhg%LS8nbDHFpWQgeLvAM2n7QLz#yK9%fxxa@gbptM$Fj8z$#u0RJZ_0ODJn9L zO7NeHAw;w+h9pvEV=;uTA{Ij!B^N^;Ei@KGs90{!>o0{o`eMk%MT*1jq!PL-lXQPM z{OXG#6`aE+$VE9agcs%JS2H3+sqMOYkr8xf2_MxMwIgh^N9=UlVNotGszfcy}R!{N%M{*x>B03HFNV9&o^PPw%gdZ=!}UDHu}O+xnzawBC(@# z8}(9Qp;VMil^eMdM+}));--?I%qww>lC?U}gLQ5?4*INvO7A8Twv5Fu*D6-x>gP}# z=N;q-_fqDVi(jr)-e&LhX39SDa3=fAl{mT09x-ILZw(|x*vBYo-*Jxr#msN;IKj_kF^pm+u_p(G!n$e}xqY&R4PYJ(6WwOt_J+vxBwDisONs!Su z)0NdsEL1Z}-Nn<5zL}aLlZ5|y^-X8rX7qrUjk{zZrc`zAX6=o;WIm%Mck!CW zT_T@`t69jzXN|jLJrJ6U(ZM1$EO!Z6;o3y(Xc6NpD34PK{?p?`w0L|1Wi~ucR}mg( zl=S$MwT8#3SZ>bir#DvJ|5;}3nN8sm@efK}svD{kkCbC?i^!f_UUg;PBVQW3= z`gm(S>c@F&yy^(JBbGjo*Myzzh_wT=l2G2sd{xT$K#bTh4wFiIn!_GR7r9E| z=!Xim6~Ud5A;$ecaRfELHtwg)jCm6Bxuqr{#ztyAj)wyDXmmo&E*c+#MKnv z4u_g?HFW73gdDEYlzN(|{_Y)R>!7%r?buj>R(dF|<~-6_;%c&y;Ht@D9)mqgTn)1` zU52qxTn*#WD38QZT#bQ~!X$xKXPA&~GE-cQfwMAGTn!WMWsa*caFOLU<7)nk#VVfS zYM76`XDJcI)tCf!tA$E&H4)-1REn#KpjreNaW%w(!|n8QQ}Q|50HJcS9|N1G7;!Zg z8oMpfYn2gKW1+E^0;i@LaW&h~Dm3@YtZMSB5pgvVeWbUX1wdR4c|qr{QAdt_5LaVG zUs`3v)%@IsxVad94>sn|<7%dUVZ_x~SONoAtDLEh!fg#b{#fMH<7x_SH{xn6EP>&J zjJO&rI(E7dS7Sw&#Yk|-Z-^PF@5l|=%A=jh1^x@ToAkJv*Y+84HKv&^lH_9M;8!ax zaWzJTioly+8gVri1-;qF=XV%!HIYIkgZrQnR};Y?0R^L1 zxKz};=y5f(HW+a=78zVB`Vql07c6l#vJGx+YQ)uSZ)bRH1j~L3F4W^{3L~w@)%0m% z#MMOV;f#Spr;NCo{iaYhIH3Jt#MM}6(!O0o)ogSPJlMIA)V@U^>Nz8>W}Ky&R{!0I ztC?XzuejjV<7zDCN$piHDq5P8RLTbLlC*bD8gVsdt5>wH=Z(0UFg&5Gllkn>R|Q+D zmFnfJ$TYgQR6Z|c7J0@eN)2_61=gC+PtOBAuBP5iBd*56H;GH%hfB2WeO`Q~HXR#PomR0#vW8*w%N zzGQfYLSt*)-FLtBK?be5}iu<*fa(Q7ckL3S{VUHP6mcGUjCA3q1JQh^vW| z5r}=wh^xs$yEZZ+u15BZo&gbYHH;3vJ=_vk!!1#MLmKtq<0$Zi%Zg@fdep ze}Dl@u|y}24`^6WurUS!BH?VrS*=%TXhe58jc-?Llxe3NR79TDx{D+h-)J)>u4IX= zY;u(d!T+<-=G?!L#DDZ3nor-W&T1t!d{!$ZBF}0q(t%by@Xk*iDH&`o2suBeyL4hh zRcfy|_S&b9`b}9 z2(;(65eW3PMbESoMj+7lmYkDOHa!q%(n%u_=!luq37t^zNRK5DC^Nxz zj;MaBqbz|y%*k{!5QuTVm=Y-v$iPWqW*`s~ZkoxQMY9xX4)HpATj|5U5{HBM``jFoHL<9nH*AmPaWC;Xf4Kfhu z^bI2rXlysbLKfv;1`G8-pz)K9K%hvzfaj7C2(*V~kVW~G^v5p>?TBL+Z8hqh`FgpQ4u(oDw}~oCQW|3wxXgL2*fmUvkC+n zdD#pEGHLQ4(@%?ddHd0%R>};np3tJ7{Sw{Yf>vgHS;-6pGQ~+V9xOBiftbb}Lqd8^ zBM`{w4Dh5JM^8%U@&Xv4P#_SEFZf#{>Tfs@D9fCPilHIAB@n0#9_N-oAi8u_AY7nb zJ@t-oSR;hyuEOX-*CPUf2<@uHwC5tv>tq^@j6`tWS@kMHfk3RLA>~0KhQw1L5D1jD z5XO9tUK&*h!dn7?nvx_l5Qr{aE!d(__l-axLTK)`jIKT-A`pnsTnJT?mODt+9y-5mEt7^ud5`yy1Dl3#$wSO517#0_}hintM5^;MKT5-JlT&^cjYuk|z95U?ck9Dg%KY|78gTVmy_Q zUR)kU%Rr!oK(uu2*eozBqUI}zj`kS+KU3AxmkALM;)DD zCz+bN1ar5zZv+BWv~b7#VFUt^8Hzi24=3Bwfx;XJ#5$?{2>$`tM6E~$0=Z ztzYj+1}!&MjXyQ>e9d|GfKTs94kE4hBt@P#-XJ3kR6WV-DG{s2WQYhZm}glvX5-1s zOg#yD+OMfmIHR2LMj#N?uVv};A=-xsoW5u*#C2arOP{w%M_}?LVBh!F zTwm0N&i#vyPIb;=wB+uQYAnRbrO!t!WN&R_Ax@)ecQHDcQC&VXcp;9gaJi`Q;Fh>p z9S=$8&yIL10abOj=WP$0)fFH)^)A5J$ywb6)>xf{fM0VVZp>(O-qR(62!TMv zt^$Dqs1mgh_w#e+LLBE~37i?T1clG5Kp<*39Q{H4Cs*zDZKHCpSh$~h)>vhY!ox^&OYRvqqjE73n}l$yB+Kkq*R=Intpj3CbJ@#3)&--hWk{opn&@-9!@p z6#R0nA`ob+&T-yBj&L_(j@tO;TIE2XH=8K?$itcJGb0^jAP_NRwyz~5McBtEX9}ApuT^eEKagjQX88*7v} z^Rw@s@Ck=KhK@b|U}yiB0d)_XDkW>7SN228UD4Jo7ov58%_g^ixRdUHZg& zMwcF8pz6|XB_g_XGDHMd2Q7m`HlEC++as=vYJOC`nVMhZ?LiEgo8NiJj%a?2lFhH{ z6QlW2i*OT3_Bm+N47{8wbx+>-l>j!t#v!d#-xec$xB3o(YQTK)KKC%>SCynAYwEEfi`!f-0vC-ADIGyM#t)bKz~pno>1|9G-sj$foK^? z1p>LY>w!RS%(A+2(p0ODrW;fsknL+d5a>nNBk3Yni8m+^=t^PKGy;M2*$Fcch)Q4$ z1S)(3fk0F7##p^z6na;Z!S4&L1>V{37t_Dm8!5#LCJq;DLd^I)n|ccg~is#Vn>AOK+Q76a5e7 z7S6V=Z!G9}1=Nhf%bCzq)~YFjPOfUmE^QHhDh$seY;^`M=q%k_sm#K9Y7WhzW)WU> z(E_ICmg@7ZP_qbql^!ZMHndKN6)mt>?Hr{0f{YWvD^t{d$D?#Sxr924`%|g2=wy00 z>1iA~=IrKlZzYbS*-SB~d-1NCOY#s5IPRt{F+UPyJE&4P5@l z=rErGLUY^MeaZWb4zoI=qZu81+UPKMShxr4=v3!V7Vf)6jBU33h9X_a|Z?i>3$<$#+4qAvI^PuHB@=4|~J)>k#x#EiI2hTdF^llBK9*MuL+0u#}P#1SJN7|@DLQ;O!qSMBHj1?xzepmCQ zz4pi@FMiX4X$SDp1XJ#5HPd$dqb`2e#%O6<&M9&CwK29dH*8_XKeRE9v|37QyUXZ+t@?p`%4>BGwsPtb@jJ41}Y}(RhR#08@05z^{Yo( zTG~wg;;}ZtR=P4Q8$$&UnsUGh++g7+r4w}m@V3&0^(&jEIZBt&uk0F@j`t6a5)(;; z3#@+fVfT#?;nYf>!|OUzqDaP&I3cg1NyY{ob;~rjrbU-tciAPcJg}m4H^f^qEr+HB z6NeYhA>u}BBAlT`Cw>~pA(l<mzv3W(BLjj!k-$1;e9*-g;8 z60M9@D}wg?72KcUa%jLlp;0Ho`9#oN%_Fu^YpJX|Bo{g%7t2ecekNR1sdx?&MZ(4! zK0b^(oUE;a-BLS~0^j7yA-=>%s^J6Z*16*rBYJ>4 zRaZ<@5zKkdE&3CC%}n^fBb!tFLuIQirK^^5DC7{$dIJ4yCUoPScCqMv6st}q^um2k zQSLCf>t;g#on{k7O2U?UnM`bU!!6PEGno?nZJH42#c(gBDLi(b2C6)v8XBnW*WDr) zp&Dn(U5K698he>i#fjjZT0(63+a<#76v{=nwFo2!9HJ_<)E6~E*kpNw_Gg7ex6i~L zOpnebMut&@t~$OD>QMxjCHusue?ojW9nX~&>v*b8e3}kCt4ab@`?xLUDXI5Du>(d@t}vn$I_Ut%8w&^!$0R5urW?l zb+lRU5z%EwHm<+aBX&b)S-i{psJ$KW3sH7LV>^0V#!uFw8z02>FMKgY(;62=&&wB6 zHDBXZc>3_g8=9^0?03|~G|kbtZ?z~%nXUyJcS0jzwi#NgLnP!7`$^?TqPjLTN>n3T z%Ffc-m3^B`vt$v@XAe5WqZMF&uV^EBFFsGjar&zHL~MFK zQFf&q(-Kw|%Q+CF7m2hg3#kl9(>J?C*$=pjk{O~Z3zt|5kC)xR%2SK%L_dl>n#yjr znEn$f@S?tjZQEo#cnV?c;48bm3S9`THeHt8g$M?8BytKaI+{>>s86!ZM>AlOXwqnp zQ~dcolzj_|g&>-~y~i%zAmg?;Ata^QtXv|NM0`TU;9|Qx)J;`&{Qa#5y1#cE#zS-d z6it*pC>)=o`fIpR{fDBP?cVQ^=_A#Mwd^s?U4(L`Htnd1k8wYiJ)sb5TE%jYSN0?$ zTuH>1gEO77V4SrvT}z*smOVo*P~t?&FxdDMp+BvFj20Wk3+$v@*nrOGeA8|J1qmL^ zRo;!KKFM&-b4S~fh`~9_?Y>Ihy+t*fFs-_53eMT?2S8Xz&z~Uf`EGV8$!D5q9y5Bl1+muO`XMnLH}bd?u&i z*(CCOeh1_{vwdi!d4}NEju+sbHPvw`blcLm*Us~yUgQK=+fmT zoS$;gijDV@Ch2yBIWT?AREY3jpD(9Tygw_t(@K{@%;QpwjIKDAPKHs`ocE$8nW8i0 zCMG4qI4*@vmCR*z=0YS);^?>()$+{rIS<6Ak zr7&}8Q!5>pV&Ih4Wwng6J1tr{Q{bts#@U?~8fy>kyPH#N$MD(9ME|IZ--s@VR@`o}|&O5*=CD2_*547eC-0o@|mvY{s^WCN9aVZJi6w5H1 zm~L3>Ujr8XxRlEyjN?))QUZBLD)bm@&cM3<^1~OL-DxRAAbqm@@WuOjCiIoo#@U?~ z^?_3TjI%qf=(F8qD1djCjVeWV?OVf*<5H~XE1l)HL*4~y6Cqg8)tV~xr28UdQ&FuE%Ro;KHh~b+) zkWx|xntGo^GKj$Z6yxm9NEKwM2#!52V{5&3gh*3IAcFbhEN6Fe-@vT{FN*LDhOJ(& zV&&E#tqkt)SkCU`Ow>6c;J8Y}*`4hFQ0#N&*`2I4H12Xv@hSp?yhZG?JN#}YHOcFE z*w6&L_ZKbnVlDIRPSdW?-TCI(oh&P1-zx}n-3?0(oQtEJwnTIg~f^SBhYa|F3FVa2taqFQILRJD_Tq+lYs*j=FuI7@TU2e38S z;zgz@hCej(xD=L4)ubX%3%p<+mtxXni`tlHcUl;C|7o7xX+dx3mP6EDkw(&c(Uva22>V1 z1ABVq5P?m(F~qfTS0{_JItK(xHcp0K?2Z{OV$%zpg~JApTEx*ne z)ipv1A`Dca1Op?_n;}C)@YYYbeRJcTaF}j9nJN4Ov{4QC}9bic!cZk%qT*M>3Zww`W7U7|eQ zCf`EUIX2fS&q6b1igCKl_n^wtZT4N40fgR{w0$VN&HX*Oz#O0BbQ{+V#nM4L!Yt>A zB`~Onan$NBX3oGTI=Y*7)8sZ!w_*9_={9ufBC(d!Z5a0l?nB%+qa5n(QDOJI&K=3~?&ofEMQIHYSbp`OBkIqPFbC={CkI4NkXt z1$Z8d;dGmHl#?F}>6(8h(tQ77ELFkzPb$_wv6fA*S{zGvX1KAIO|8S#1BG&tpM;Ov zw_3~A-^{R+}ssKRDLwcHdn zWM1wH_^t>IM216iv&+CYfi(joeDA|1Dr3}5bWx>nQ*eMLN#ylDvYyxb7A``$3RcBi zhzPv@xv}2o1_B@FP;~}w>FCPNQjA{5=p9MMdf!G1x2=Q`l5)htz5m-7u^bb>&N|M` z$ga6QVq2{3R0q?WLi&)T<;@>%t_i3^#hFJLAbqy)n#6{LteOPr&Y3;FM37QJ8k{%ybrdjG?1v z5k73MiQ7p8UcV^U)IGbL<=>)4QkT&FC3s0C13dGbfn83yzV7+fnQmcO0~We@Jae6a z#J_CfVYht3bHv#M`E}vT@_Quutdm}hC0Z^U1m~@RW zl;ygjk*%(uV3Y7~hBb79c;+|*vyZq%IZRx7Zdyc3zCio|w>U*I?q`t^cl++mFIv4vbCJuH50lu_9v3^B3Dn?Ss42};#%9!%Uw_j^4L@yRnFr4uCdcV9A$o1Hl2YobF;Gm^?I3X`;iKLzwHd?|OPQ$ClXnsQJCc|3Pz{A*svR~m zr6d=X!={+(Ck)OUY|JxK>@$2(OBzPngv2~6F(hBe40R;t=XdZh=O5$lpoT_4<=cpY)~_KF-_8!p$8`42_JcvJ^+p>lX6R^ zHyucHc7ty;lJw1QOxUN7R$@x0ELKx{G0jX-DJOK~3ugY*-_)QlriE0P65Cx)m<A zQY&W{=ptvuVp{X+hOB|O5po7Crj3Pj@K%QiVx=smtp(ZeONR&(vYiFlLCrqJy!7mH zqqtX4XlleU#eMpqET%}xQl0hXKEx_ZegmxZY>G)rNmo--G3`xJDYJBB2QyRZE;V5n z(@A=s>=CK%SLJkFOlRqY)ZBO>y8eet#B`BtBtfLsRg+gSU9H%fw-j$TiM>ztmO4gF zXvK85V)vzL;v&iI$ykU~^II{!6k@rWCyD7J^GO36sA-azz9!ZsjVg5|r)ZBOc4Edz z5;Yi+I;dBi#Ev(y^0V30W(5^#qJ_j?&8B{<#_}SCSayn~A7o@8+7W7MjS5nZr~R;j9^5W0D~ zH7ivUDdmf4V&XlQs8oY%GiE0Q*CxhF&uH#^xZ=fUQH@cl3RRG}oX@EBv`RHYxVDn2 z4JQG$BuY4Qr`tp+?3-8VS<g`z}bsH$+tmYTc}V>7USBe*}!1!XAIWuX0ZMs zgAdLy*l>lxhj$rl`iH?suHB^e<6I0j7i92BaR#5JF!)R?B9_ma(^X1mc5+IWm-(ve zWCqaSCc{iRtz%wFc>(M!Jt(PhU{W6>1`CcdSokZ0#d&aCQhLf;#R=4^SD8V5c2=zhjmU$w z(i$?d@o5H4t}tl&h(WWs{lwC|B!l$l7_{ibpyfaYttSCIb*>D)7e9_4(Xvh*Z8cCW z>(te@Gi;(AW!O}^&ak;gC2U!zmG*?M+i1DIrR#QD5r!{ml^M3z8Zqpsz09z)){kK~ zZ5+cM+FXV`wN(uJXj>Wf*A6ippj~A+Nc)%JP|b%eV_Mc3rX?^OuGMBZN^8S#tk#d= zcx@cRN!nb7leJY0-_W))oS}WoaHe*S;cV>=L%b4vNAeeFeuj&+k_?w#x{vzPTRW-V{Ka)`fT4Y%w@a4&~N*LVVo`MDDL`t zJqs}CRgyt(?lkK4t;tvYS~2L~gF(h{1_PEb7`U0iYu_;#beq9o_c4+=B*b873WH&7 z7z}@n!HC5SMt;s<)OQR<-(oPvjyJ*ddSeSP7+0FX_-7eRXv<*Y1O~5fU@+xd25
YE>lpOkJGLje!sK#JmBLa<{d6_|K4+b>{GN?70LG4)#o_&`=oh=ONe#79o(+uj}WKjPx zg9fpuNoHDzLBom+8r5a+d@BZx`!HxShC$QW44S>i;Dv1j8V~rM!9Z?3jbGzuP2)jq zXXC-#z#0#+pCQhn@eGDlWH7ubgAu(LjGWG3)Jg`UcQP1rp265(8H~$umZXeNU@#$> z!NjHvCUs))`cMXwXEKkX0UuSgB5!jynCL(dw(%lndbsY zSyi6F>gO4(>A_&_R0ivoFnE6hgZ1As_~0gk4c?2C{lg>%8yhhAxG#gv!x?Ou&ET_@ z3_kyq!L}a=G%FSDwTV`THb#lAMe_>h`X~-+j4z3|LSA*L@v;yNy5tkBPh#W^@+0JG z1IS;iwVhichlu?rPL#h+LC~6952DaU(XMydD4;prwp*@fG3iZ@DF2Ar+U*!kX=*a< zVitjolP|vX+a|Xt|77)#^h)~jZixQvZf;TjcO{mxDzU$Fy8T12OxOb!d}PvrLIGOS z2~@Zua%)!N(MXGE@4Xf!GRT75nkKn&TexyFS8KLKreEyH#uU(`HLdzJh!Hh0t(~J+ z?52-VQhw#97eDq3u(asXIxauv?_|1Tq5M%IN8ebQ8o>MYhqLg$n4_>wz9)8~oSpf5 z#lkkxe$?|ZV#zYB9~X0I#+sfnGg_k!@I0}Q-WlHo7ITou*1uTNC0=Gcnb1+-CCi!U zpcfU<<=OuDKCf0D(R{s~*CyiW_Xy_e;&;Z_#di3kwG)TqDst;t2*lCT#}IamH1Ua6 zUsv*rjVQgRz5FVWOJ5omaH7*os(FB1Dknne$PFqjTD9mGBho4FoQS;aIbh8!GA&wl zh>j8Ke$FkL_ll~rg`7?A-sCb)&}zIiyH^yug3VUx0oR=ltsvDW`~i)UGSXLEXmSgD$SZ@8rtGEK$~-zGd|?A zv+43X$8k<~86ZSL^x+uM`%0W}zUid)6n`HtUK}1$0c2O_3#dIr22?6ei=Y!-hLree z@JD`BapHD-L>2xNq0!S^>U&fNj&9paxet(rz)=-Uiv6q(0b!+?`&kjc2rPZi*w4zs zD!)ff*ktTyb)3bV!LJJT=#yW4eVQCKxKqVvyD4qKPwgnU@BV^cMZrZ|@f-M9pQS73d=&`I{VwGX#C&0VP&$p#YZ(2V zK1)~4nd>u?yLd@sfw>~1CHGSYjLEx?sN}9sS;%s8f%yv)9eieoW%7=!aP1^^G`3#- z)#M!&h3*q$2cXCWW@5-ZdDn{sWuClal$^ZV4}P`4Or>`dN%;HYm!`>`n7qq#QE{Ai zkR#k)duswb#`kdU&d?J2i5g~S9 z`YxV6YvL6u;uKn9dwh8~Z!cy_PTHaiRj(8+($6DIv{W1<7v{@L>eAI}3^GXEO&wPb ze3IbDm%`!`1hk|dvq?Gkbf#(~EU+h4#)YTToeFcr;o@V5VybXd>M%ViAFw zLHX5GdbGU`=V`#`uUpteMa*ZWd+ncdOJsELqd31r`*bN}p6FH$rJ^q=w3_5JE}D3O z9hKvsJYrdkrjD$B>i%Fmc3t(meEAEy5;V>Jcg1M=IY(^)X)WH<+#CHcb0B_1^i2?3 ztYQ@;mPw)-Gp@5q#x2C?9QdvDL5mHaeKinP~4I?be%&5CruLb}eR#j#kBB!NFzNHn+-&b!Y< zNzy?JDOU_lO!p|LNQW$>>lmU5XWl#>nd`8H1XqJ}<|aNBBwa@=B>Lo4IFs<XbImbD zI%OfX`YEeq)!NUqTn z$+)7Ba+r);Chv{AvRMo90)GbI`0qSoVN1+^Wa+f35FLG$2TSE0P=fHsw#kWI@hMo9 zFYy)gX4_2vmZBK5!oYARTg}zc@|hbRpguq7N=-TNK?hCzggq(3gEFDrbJX{&gKhGA zR^|>a)W2sPf?ljIc};%L`ilNN>(EU2KvTQ=o^@Cz>Bkb(_pHM+p;zeNvyRAwzM+55 zIx-Xb#fIv8*3p?v+@yccIwq4Tg->EtB0NFIacg@11mPyyxQn8mjf*4#`A<2-N_>_W zo?;`vYHsPOM@9V-{f0ub1Be3$ngrB`tTSvRTF+9WxLMY|}Ui>^gr2LvC%n_KuDi*89P#7=zIW|NKz{$9*4KkHqk zP_pL_4&0Gbes{Z8$5RPKFvos{U$5ieXZ*$OvX>8ksN*I7RdfXWJ?Z0-#EU3_)74xSK+w1oiqpk;AvNRS6Bj6GII)#>F5}i7}1okF~ z(JxAB!NjSERN)+@upPlL{h~CsBN(S&l+mh2UxdDvQ@9B-*TQLjpq!DHn_!B617M+BF;eSRp&GrI|j_`1^U~icTuZgdKDzOE0H4( zqgQG<-soCdPHgB}EHoPTY~h(GFX#mm3Di za*g>Gk;Ny$`|*2*8N#P`HZ8|F?;miA_QdeHg~9m`vXvn0PAj%8%6xkw4BKa_a9PS6 z{n#T$;iKG^-2R`e4u+btB=DF?63zpUJfaX`&zV@2VJSNQUr5)_7G2W~|5kfI zzQ1OZ)hDm6%PZFcuAnx@xYmcLrDPXn7y*t-_2XK*=>_<9JizbnC1LBiu4mQ!5q2zwtWH2ci>5zfu) z9pWj3xVC(3k>=di$|mZQj(@G#n!wg0>=O$%__(Y`Y$wg=A!S=*)xo70cWfiPQ^)hO zGnj91PEp}i;G=cCY0fL_RG-u`mbPcW_qqCgBJYSE=gs>*Q#YY-!FtI=?BzPISL53u@dvZ9ccjD0S zE~Jw^R&wrSkC;pMV^AmOFv%_wD0;kvMt+4%QCoJ{d|nHW+1h)|iSvl9q^qbdEXKmf z!h~-kUV=8je>u-q-~W9ac0I#DaT2_r^SbPW|Fz{6ucW{Bf8VL7s)goQhiQ$&^iFlE zrq6sWaumjh#f~?U^wX`4J~{n+M^lVy=-n#)OowVYu_r_NC7er6FD|wD>ax6&y_ZDY zR;UU*YpnZl|W^PSPJ1#I=>=iB}T}>3=FTaR}#@mg>FgAF^I^hY0KWBe#03 zdSp>6dR$iZn=Z8d-+-IymtG{L?M5e=ez3<}RhQ|S&Y8pHbWvu}BUf%&Md>!3CngKe z1$959+qJZPtkGfNX#rGrPlxnF#?vAFaF23-$h#!nrOR+yWRO_t&~7oP34Y9(WfHAU z-0+C~f8`M^I@x)MYrIyseu$Q%u&v9Ze?gk&`$VhB_`>mPdtT9^kV9t4GP*Th$)ym< zCxsMtOvVPX;#COZzoz)rdLO^#5d+&Goab@R^~q7<7W&3Yk4amv1L%YGzusCi+XP&+ zI$k42)W?i~>-$(aEv`=iv@V0$ZD2`9>*AFDfzut!Ae-w@EKNFhtc`BYbu5;|cYGb= ze%Db>R$_)fg|Fmz&6#+URtmYVIX;V>lNL zl^^#q8ZBL=qrprnTHFqke zRb0GPk3?a^9Y#@QBT$mKu+0vm>d*{KbT>jR;odwNqL@S*hLDb%tfNsCy1=8GLNm`H zezQ`u=-Nc8)ExUxn)(=(u251RqgpCdDW37!Gb0CoPg|)~Wn5cH(KkqD8#aYX#j-{J zA4}WByE#B<#|;*vMvbY}NSrcs@)WqIVrTm}z;&=yR3l8qZkqcq3N@8i-Q|_*UqVIC zd>sruSQ!;hGWLI}j8s)gVoc?sd8b~VyZ+e5`3 z!IpDT(OzQl(gVdy&o%FE%0`zNbeS=baHoJ9VEs1LdxN-|B?^(Z0Va(zb|4koqz8(p z4J;ok#A{yM+xf(xx9~+b>H<*6B-yVRx<%FYD-uIF6QJbZwm;0)B z8&O)90Ao@7WPD4PoT48uU3y7i2FtoeR4S)8tsH(H(j}!b=!XMk2at=4#O{WRozWS@ zpTYd}lR@U?r3bmUJo?Mq(9Qj;)Fm z_1qaFh(IatBuWv%8%hS11Z0pX?>j^woc9yTyMZn_#mt=I9F)qqR|zcR@RMRnDPC*}yKzfdY4rRq453Q>xw^fQ=Kl?gYV%0^W0KC-U? z;V6~CKTIV7UJ^B!MSWHsm;H&4KGgA!sD+;~bjhhrgnN@NImJIj$lw&^&G>+*oN7}8 zmtW8&rMyJQxJoRC2uG>G%-8lA;C?0?r3TZF?G7#-7e4ifrm^w%Q-FM9J8EO|FWUMm zwqCTOOdOWL5eX1mKj`?Odz3hhTR*lzl4B^AuKE!^t(;?7sVG6-h;3Naxkp5aI!RF? zHt+ML5eoafymggS})V`!9*;WpC1tg?*M5CH|@c z_VN~X>PB2`@N~3rR-;nICgZ$Z!t)ksR0>xjO6;OCxX5@By_DE$a2G|+V0PhbwZtaI zV}us_46#Zf!Z{Pz6@*QtygD}eutU^;4^nE$-O@;*aJE_N7X`2bWNaNC^SV3hX5bd1 z=l;I6*ifv@5Z`d5zyH{S!->3Okc^{Zx#l6|szB~~1)dV##kkJ<4u1Uajwb33lOZe#s?hdS7d5i%x7(K1vM08U_aAzQjFaqr@`0c)^x` zSmXQXK%qlxZcEaJeO?KN-q2OLtsE8t@qG)^TG*;;!!GNzmbRL(p)3?VUV^uiceUKK zJVI%Qb|QQVQQsoGbTt;b!h_df54P~WpMAm}{`iy+9rj#coZ(|ve8Ls};aQ)E3SYe7 z6Vc%c7k$DV-h37xOok`z$|Z7yeURe~-@op|2T{w9_=GR~(mkKZ6;7KJC;Z`2H+>>s zc-Ffrm+-HJMln>`a zu8QH0VM(R%32;^pkH6{@Rl>8Nt7^C?(#hciNLLGwJL418!`C38Mz}ailoAe|^NDA| z*FjAUZ`|h-cX!=9XAd{u?-M(YP%7~YpP2a*rCvvB;NO_Ys`NS?xJ%R;ab866DpICE}sEd(W%c-0HkDRKA)K8om-4{OimnDz&iA|j90;?8Ix{Vy` zQI18NdZsq~GLLZGk-EvLbolDf+k|_40ZP7`QUe#Fw4>f`=C@dc;K&Gm_8 z>nO(xNLkLQ$4IT<)Vd`;@h+#*7Wu?`oU*~v$sbXUci#4iDV+Kpsi~aW1->^pm219F zOyg7@$eYfo!QeZ!lk#?g-qW0lLh1~sN-RbFa_S)X&T*>C)Hw0yCCYJiHhenfSELR@ z@}UKks)!Ff4s&Y5yf|_96T;mkukEGOjGei}!pD@ljrKQY;$5V|sE;)VD7E)1wBnrK8EB6oLU9G zhn(sL+@GAPwE}IIQw5Ovn^WgNJv57~Ple5gIrZIJabogX!aYJ8I<=Kj1<`k$=G25K z@ZS!?9Ybm-r@A7wOQz<=iAxuW+GAmy*z_xRe!zf)EbH3qo5A5hAH z9KUgDBB=K`bplrX&Z*I$-ser51wv7pE!=j1$Y=dh(qtA_!=!a0~*qGx%1+nB@+s}!YyZNf1BTt!K!B>d* z8rq^YF_7Mv_&sNg@cDthMH*}I_U|_+S%R&bflOK_Zy7M;rGb~X3Z-h`$5#(OMaSbD zin!rUfL)P2K{*|B7%7P=@(?I2=R9cz6QF|7x@&X0wNR&@j?Ocq#7W}s zm48Iz(NW@OO83rh6TVeQO;3RMl0597q{Ck%EXHDl8oqOyh8+zi(y(I?e(mAw=V{n+ z`Xq)OvTP&iwN79gtLqTtqgcUKkne9j+(|G=^S3jNebHjA3f6`v z$KujA4L^TW6C!RJ&UpZgj=P~Heu&+qw>`q}@RlYLzE87@SK!IGyIOgSq1``Xj4To+ zU>lEW#ew}@8>D09Y!(f)T^s4=C;W(no|wLUjyNAiaEgTGt|(FOYmbQgTg&HBqUAt6 z;d_v(><8(wRx5(!!US+-$|Y>1iw$y-5iSzqdJR7!A+}hQ=ui||?KaasN{NI$`C`Sn zpFncih}V)|($_(LBB^#q$|p;d{Mze0;%&V6$9ZjrS6qLw>a?pKu^6$~aj_N>+eZyp zB+S|E6z?HYH_mUP4AP;Y53obH_BpV5YzmY2N1GUjX@a=?I;QAt4_>E$iI*7pt!zSS ziU*;{$XeKCtM#g!h;5!&X!;GWPW zt>}ce;m>OLgf*^=#h=^?q@o4L)}6AIi&T`*$&Y}UvCVAUMl(=VHw2cP*a0E0T8v=dQ63bf=M|S2 zUk63WmO&Ne&+#77;cckOo=FzvvR#NTcS2RqNPCs4^1rx5qqNu&&mO-hiG|?kIB30QlNmad2s#mB~y>0tYWAbLU zs=5mYdP!Bb3`*5tlN+O&?NnFUGALCeP*<0z*=5fp zRoT%jW|OMEmixk5s!}M`bEGO;2Bm5nR2898WzQs4bwFJ?sIL0i@*}h_s{>y{UCkp0 zX3L;dJ%9rTgTVR@DZSYCn}KTLz`7DpakaQf1F1RpInjv4u*N zVQZMJs)s05p68${TLz^n11<0#l`4BCRu$S0RezGIftFrT^+cg+S6!kVsTm$glqy0W zK}FSfpkibe23e9r*cJRLHH9USJp}h9>fSAK4V6Tm`)@8)rrDEFQ{=w?!znetj}M0r zQFXl?*iNI9l;*o=Siey}^M5#{<|)v;j5IHg>};%>4?%Ma(){0CN^@ z|HCOYKY+L6sGe6u_B~e3Ls8Ew$=m0k|xu=YyQWHVRx@Y~}!- zmGS(!918Ej_$c)on6x#rbE7;Wq4n@Mk+2W+&m+4aN#6$g`$YdDvZIjnB+xIC{4XPK zXG!l0{af~ez9aIcll1wZKP39D$Xi3w-+=s{qxJO(d31_n~(BoYsoW)?fIh-AL;r|S_F&q*$y6GQVTAQW)C(OR- z5}W9L&z3>maF_7jFoSOO?3rZi_j-l6MXLU_G+e8y?zdcG1a)fJGALE+r+P#i>d&%g zlB#mYAf|^plqZ&Zz^dv2R6QY8*)k|qmEZ7)bEGPJCaLO;974>bQVF{`*tV()LDkcw zDq9Anss~CHN2;=ClB&ky9d86Zlr+0J*tV*2p{~kOU1iIlRJBE2d8w|lXOgNMXck*Z zmCbIx%3D=E4^@3gRkjRD)l#TxNUE}DlB#eXuP9A*Ww)DyZL6w{aNt+uz-$?ms(WzY z5^`YnOj1=e>grjlD~H`2Y+F^GL8<BI%4?@rG7A%T+6g5_#)?A!%r8m$ ze9#XNy@1_(JLYmo`hCcMLh=hn-er(ZqDEIR)Uekqs5hjJ zNU53Aq%IyYxE1KBcA83+LWol&cwa&gYzfRu)wWXxljK@V^w7HaDDf=O>nh!p%|)yt z;lVwK{2jMReT!N-9%~AXACks~Su|FL#+D?pF-Q7l(OB-fN4!GxW>$?-Y=yi+G$pa= z7O}Yskule77+ruI*UH`u2q~6ID+iQxgNcOqAG$>=Y!VRnqUDYwcIl|lQ<$ZzMfCPc zw?R|0$qz8k7|I7No$T8)X%PwK5iH-4NL}o|N081S*8{Sxo4o|Kd@yYj2@^pYNTgTn z?ITDlK$=dZSMBp6NO_>EKI!UZKM+CMj$Am{8q-2{Es$B)^T;)Va`m%Ui6A|0=Mlq# zaQXl{)w{HiN+_E_LXQ{mR44jt_Gv~|DyE`;i~NmhjGY3ScT@<-aEgSvfGbVZ+s`~`_V+FsnCQ~4Er3G#bFppUgb zXVA$Bk{((a?Gdvn{{&U>M%i8RE^g$(TQD)at{AxRNVDK2)4$wdwlp<}r`;ydD6tGL)VCKq{0g#O)%Be6*1 zdd0;KGP%fAB2))+?e|F5hl-26WO9+eM5x(OkNAvaeWbY9RVEiXO@y|hGb>G8pD3;f zf2Ai7S4a436mfl~xFY;Ti(Dc!2>x;r*B6Q_!e89!hQ`BRv&s6e6jy}5cCyBD=mkC} zu3d^N!e6(TYu#r!T!}R9QCt!J%2$N!ngoAcAX)nqSA@T6GuLGJ>phZnKygL*t2c2a z6hZ_17@^^D2P20R^Ff!5FrgCGNtP4S(Fi7ykbxzjlL%#tJ7FQozI`(K?)!hC?>?P{ zv=gycpW;96oQ0I9C>1UZPQOEDUsPuE^UbVg*+@e_d&IxQ^;7m-pCfEdBs^;C5dj>_ z8F$4_p>nblrKgkXWG><9lT7q$N($46RTaD=T2m`xxS9RK_!NxoLG(LTGvvd#HUKq4^-KBhr19jTl5iSA6smjd1?Bhvx87B;;M|7F#fT8TYs45y>|4 zXeD7i+r9_efSU&8%1SU8fn=)G`{>Rsqz}Z;6;qTo0 z-Fs&_Gjrz~b6xu|TtoVdwMl3!$-bsgmXI||W9@cj>_S4yT2#tf_AM<#2q{Y{NkS5p z{#1(A|MQ&hE}x0~e%^WB^Pcmb_pIO9?m4mm8^pdnAWyh1<5Xi)PulbPJC77qJL_rl zH2o5;8lnMd^W*evTy~`J0)d)(c>PqJo38EXzG0Tmoz`B&o964>S{+Ti zd8y95RE4*$(7Ac~G~KtY)45}+@b+yww@H`K{mlZMTcXPUTl;kGfhwJEAJ)0)xt)IA zJ+5gaaFB0#(pmX1{6c%67c3sxFJ=qnDAZfd=g}5J?N4!T9A#Og-AhS14 zgt*DLn#?{N9hiV=-(E8Naddzihu@GnkRd|cAk>q=e2^tVEin--L*`(%2yxS|KA8`5 zM2MSvUCDfuD?;4J8%^d=Q=CeGw|Qg^w-q67%xxiaq>~6qcsoMoXb%zMX4_>lANLa> zZmOlEfH^i)gq*OgGMP_Cix4-;nvwZ5Uxc_J){o3*Q$>iIUlYh2pCv-vWWK&2Lfr5geO<~Ty!?8qkbTdpI-{fzs_TyN?Kaob`znLpY(Lfn~{Pv);qju1B= z-Xil)4@Z!D3@6D5(a#a&J^~gtu;3tuI)dCQC{NBMMmvJs6KG7%Bk~~jRU4!)FJ331pFNCHr`F{Hj&{Ba*_BHxhf*d8RU}iHFCF$Y-f-Qz=jW;DRP`aF85X; zmo0LgL9XpKC09)}bq2YR+nZc<(bgH{s%<{G8lsak$R*mvkc*|N`>88tIfGmoRUJ@0 zG2a>F5~%8e>Wih$AlEvxsO4_4!WrbkW+QUBVx2R{70jOG8j5YsAeSn~k!vIhoI$Qj zE+*Gl>~jXW0J($QJ>sx4$d$$uyO-?HYuC2(@gIs(oL$003)`MJSt52@I$kBsbQtM2vgUHo`Tss?0?mp2} z4|0)g9=VR9EyAHjZXkER=%fd^^mT;X1EL2w)ZNSEI*ERIkc(Pz#ldwJL-in6u*#F` zB1Y>$E?23#`;f@jgIt%&rL4P{st36W)rDLSF-s3}&1pEfhsAt7$Q7oUq$XfzjU$IXQa@D6Yx&Gp? z9^?{F6LJH@apXL>p5z9K(|VALH&2p#R9w)5T&Y<|ZjiXF2e~Y>h1_6qO%HMn<|w%# zxCJf91(zSm4Ha>&AXirsFz-!!On6;EE~Ny>4HJG>kP9aR$qg47t{~S+^2v=5S*{>g zMwXBpDY9Kbu7zwNH%jEVf?WPk;YN#GSCA_nA5az)OKHVpjls2+L9SNhk$Y0~a|O9JF@xM#G1L|0Lc|Jk&6$cgMAaw|krcaRg-ndDZ9w(cM&rfbQq5uMyYPCyTndqeba z2RYHaLT;Vt=MHj0X<+J=wm}Sa2RU)9L2io}?GAE+*p1vak?#(2A~=@Zn_{Xv$O+$4 za&L)Q?jR?2ACP-T%y$Plf%}zQfmrGea-voiQ>nCFVud@%30X^WyTv+pkQ1*_a!18AcaRes)p9VD_XIhOQ7z{a5$6eV;^M=+Anh~Z z^#nOrsZH*<@Oy%sqBJFULS%S?oSJkZcT!||f}Dutk^53)dxD&MOd)ql^=S9S43KhRtbr%gKN_u6!^eE&Gmn;PAWkv93qs=}^_X8V-Yi)9Opg1_B!4#0Gkk&Pifa5>jJ_{+cWVLb6O?&6JR0JH0j}#gr|6Hzb5mR z17DBZnFC}+z|^|HvKoDIiQVqACHU)O;Ipr6N1xY#<%9I860Pzex<_K2UG?($h@!ZA zGp&qwI$(X;dzbe*Cc||JE67C*AIn1`O|GLO*XOP1mDrLTprlZA%1*VKFE3IYEkf&% ztXIcOrqe29OA8qfnB#f?j7X~+DFRuBQ=M2S6`fj5mUmLZle1Qpkj=p7i!gJ4jIoYb z%6>O0qDuU9mX0x#iSWd*Ev)6TjNW2tRsk%@J2xt@GUDTZJBAN}$scbavUaAtI7Y1P z!uC~>=ks`A&_thH%F@eA;O5;Sg-q&=qT{abo8?uVr1Y5I>HanmyW4AbCX`}EPLq0`fqQa+@^_~J8$$C`Z%R3N<6IM*| z;8}EBti$I_PF+UxE$4MZ&o~O}d3lZESi(Sx7yfXO4<9<2*Apo!?==D6rm&IvvG5MU z+q}G?a200CX%$kA;*YL-c`;#8)~G;AdHm7iWKX!*sBoxaI{g%C+4gvfah2*;@^C!${?m^Y&%^XnsG-~A z8TViEa6GU6rynbx{qS=`8@5Ms{+7aU3?8h5-8^)-__MfB78~{|)spO|q)`2|Bwtffs76_mzbGkG#+IZg zSLOH>GTa_=D2`P`yW$SF5QP=z-AZg(Je%TJJ+>=e za|=;e@dvjOTZ+GO@c^hF)5QxB54CznASF-pa+4lT$X3>CA-`Vb$cqxvuxR`p$BEmi=*RqvQVJXN82 zOMg#EN~6tD_24D;la8*YVXMB3r1MaQvR>x<}rrLVc&wRXZB04MV9z zMYd1_;Mk9$n#dt4R9_Y9j%cV!45bbk*+MOa;{=AfSH7x3jaQ*^qM>#$lsa@|3-u`+ z>oHwTUf-FpCF&7SRMaUVpR;5ST&-} z6syC3O04qR60>KJ$0$}u|CCr|tR-gWAb+M<9sE;bm4lX;{ev{P!J&@*DY42bOUy1p zR-;%Q`cq<+CzhDKglr3Or20nFYn@P%kJ@A^#jz8Ra;ish(b&gP-eNj-J4 zQRdk^6gs4*&Wp)sZ5|4p&r|0a!e* zi*hd`Q+5Ba&1<2&QO6eL6?#?e;18SELb;^QF3OVF((nO^s3rN zJDXQkd15)IPBF?ndR1*D1XOs?5<=DHfe%z`P0Vff4+>nWAKyt zwDFqW?Ab7$5T|c#YhA0GHW9~gzWBF#O>K zxp@jtD>ni!ul!DV`IuZQ=f4)OE#O@+ftag%E<>pnSZ)%u9-53b_bi({rd5+4!z$l# zkP5E$+Y+?gv?M(cJrbC#Yk}yQz!W_$5Iq#=)x80xp#?V`4c#B0=?{`g(=!6JQ%Q>G zSpk|Cq$FL>4$v0m&8O#}|D&_YO6DK#KfQssrCzf8lw)rc$C4?TMUpu$UxA-Ud3gmH0={b+V0{=z++5#D$d^-PDx&F0dYL8yY>;uv8|~UzGW%8DVCn| z6#1(i1Qk0VL>i=dx%5ILn-ftW-=~zp@~A-eqJVDlq4pqoWEE1L6;dIH@>1Hu%aS%g z3+Yd>%ZQZQVG1^qB^pI(9;JDd%90Ji9-;JMqA!TvCHjVlQu!KoHRUg4iAJdq&PrgH zGFkK|2j2%&lx{?MitTtm+-{>AQJx|y1l3DMG)hIZvy+B{$k$fmIFiekrSA>jl;yik z(=}Y+y1W`RREg6^Cq+;XJ_f&-`v`- z#MQF(@i<@9uLf}S9Q{q;nZz}6^^IlYv`xe{o9auUzh_P0T5a_=>v*(KE#TUn^nd1f zwCvizcl6LV0UsgG>8G!~3kRKv?;NT>fK$|c(ExmPM(cUl)7+8+d{@5y`xcxJyc4+Y zR6PJcZxYv=rH_Jp%R0dI=j#n{C2l|ByO-)6k=_@Gb64oMm-cA>yMP<4(@&Q}yu=N+ z>7n^(gLQ!$73iITcn^wMvb^w9mm2WiX$S>5wZzzGrYq zh|GOWad3C0M?2pbOvkn&l%4I-9QS~^zmo{HMm`jfd7y^~87uLfY67NHKM@MxP{c|y zorj9hDHOrXd%<)WEkfJIBxt3Zf_X4sgxbtX(7qz`&{Pq+R2jG8HUrajmIz%yq}R!G zn=eAa<#;2nIhgKCaVi--x1$A^9xFtsG?;B<9$qIxtJdPqMlz3V!-;7yIW55qC=j8p zYrI-tGQ;l;ZzaTdJUKIGLp4FIzP2ay*&hzoBY1@jgTBEJT2 z_mFuT2a(Hk^J+uMyn}*ol)G~27)KM2h3 zp^nhI({Y}h%%0JX(0dQ#vQ9Gl@*Safpv^xR%>Jp4P_Hgttvs0nvmBup;jIms59T{U z2fBK-Aen9AtR6fB%+Ym@&>v9HZ77(Jw>d(Szy!%0D{zE%Bg}J; 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